google_cloud_workstations_v1/

model.rs

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

#![allow(rustdoc::bare_urls)]
#![allow(rustdoc::broken_intra_doc_links)]
#![allow(rustdoc::invalid_html_tags)]
#![allow(rustdoc::redundant_explicit_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gaxi;
extern crate google_cloud_gax;
extern crate google_cloud_iam_v1;
extern crate google_cloud_longrunning;
extern crate google_cloud_lro;
extern crate google_cloud_rpc;
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 workstation cluster resource in the Cloud Workstations API.
///
/// Defines a group of workstations in a particular region and the
/// VPC network they're attached to.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct WorkstationCluster {
    /// Identifier. Full name of this workstation cluster.
    pub name: std::string::String,

    /// Optional. Human-readable name for this workstation cluster.
    pub display_name: std::string::String,

    /// Output only. A system-assigned unique identifier for this workstation
    /// cluster.
    pub uid: std::string::String,

    /// Output only. Indicates whether this workstation cluster is currently being
    /// updated to match its intended state.
    pub reconciling: bool,

    /// Optional. Client-specified annotations.
    pub annotations: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional.
    /// [Labels](https://cloud.google.com/workstations/docs/label-resources) that
    /// are applied to the workstation cluster and that are also propagated to the
    /// underlying Compute Engine resources.
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. Time when this workstation cluster was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

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

    /// Output only. Time when this workstation cluster was soft-deleted.
    pub delete_time: std::option::Option<wkt::Timestamp>,

    /// Optional. Checksum computed by the server. May be sent on update and delete
    /// requests to make sure that the client has an up-to-date value before
    /// proceeding.
    pub etag: std::string::String,

    /// Immutable. Name of the Compute Engine network in which instances associated
    /// with this workstation cluster will be created.
    pub network: std::string::String,

    /// Immutable. Name of the Compute Engine subnetwork in which instances
    /// associated with this workstation cluster will be created. Must be part of
    /// the subnetwork specified for this workstation cluster.
    pub subnetwork: std::string::String,

    /// Output only. The private IP address of the control plane for this
    /// workstation cluster. Workstation VMs need access to this IP address to work
    /// with the service, so make sure that your firewall rules allow egress from
    /// the workstation VMs to this address.
    pub control_plane_ip: std::string::String,

    /// Optional. Configuration for private workstation cluster.
    pub private_cluster_config:
        std::option::Option<crate::model::workstation_cluster::PrivateClusterConfig>,

    /// Optional. Configuration options for a custom domain.
    pub domain_config: std::option::Option<crate::model::workstation_cluster::DomainConfig>,

    /// Output only. Whether this workstation cluster is in degraded mode, in which
    /// case it may require user action to restore full functionality. The
    /// [conditions][google.cloud.workstations.v1.WorkstationCluster.conditions]
    /// field contains detailed information about the status of the cluster.
    ///
    /// [google.cloud.workstations.v1.WorkstationCluster.conditions]: crate::model::WorkstationCluster::conditions
    pub degraded: bool,

    /// Output only. Status conditions describing the workstation cluster's current
    /// state.
    pub conditions: std::vec::Vec<google_cloud_rpc::model::Status>,

    /// Optional. Input only. Immutable. Tag keys/values directly bound to this
    /// resource. For example:
    /// "123/environment": "production",
    /// "123/costCenter": "marketing"
    pub tags: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional. Configuration options for Cluster HTTP Gateway.
    pub gateway_config: std::option::Option<crate::model::workstation_cluster::GatewayConfig>,

    /// Optional. Specifies the redirect URL for unauthorized requests received by
    /// workstation VMs in this cluster.
    ///
    /// Redirects to this endpoint will send a base64 encoded `state` query param
    /// containing the target workstation name and original request hostname. The
    /// endpoint is responsible for retrieving a token using `GenerateAccessToken`
    /// and redirecting back to the original hostname with the token.
    pub workstation_authorization_url: std::string::String,

    /// Optional. Specifies the launch URL for workstations in this cluster.
    /// Requests sent to unstarted workstations will be redirected to this URL.
    ///
    /// Requests redirected to the launch endpoint will be sent with a
    /// `workstation` and `project` query parameter containing the full workstation
    /// resource name and project ID, respectively. The launch endpoint is
    /// responsible for starting the workstation, polling it until it reaches
    /// `STATE_RUNNING`, and then issuing a redirect to the workstation's host URL.
    pub workstation_launch_url: std::string::String,

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

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

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

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

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

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

    /// Sets the value of [labels][crate::model::WorkstationCluster::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationCluster;
    /// let x = WorkstationCluster::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::WorkstationCluster::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationCluster;
    /// use wkt::Timestamp;
    /// let x = WorkstationCluster::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::WorkstationCluster::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationCluster;
    /// use wkt::Timestamp;
    /// let x = WorkstationCluster::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = WorkstationCluster::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::WorkstationCluster::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationCluster;
    /// use wkt::Timestamp;
    /// let x = WorkstationCluster::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::WorkstationCluster::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationCluster;
    /// use wkt::Timestamp;
    /// let x = WorkstationCluster::new().set_or_clear_update_time(Some(Timestamp::default()/* use setters */));
    /// let x = WorkstationCluster::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 [delete_time][crate::model::WorkstationCluster::delete_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationCluster;
    /// use wkt::Timestamp;
    /// let x = WorkstationCluster::new().set_delete_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_delete_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.delete_time = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Configuration options for private workstation clusters.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct PrivateClusterConfig {
        /// Immutable. Whether Workstations endpoint is private.
        pub enable_private_endpoint: bool,

        /// Output only. Hostname for the workstation cluster. This field will be
        /// populated only when private endpoint is enabled. To access workstations
        /// in the workstation cluster, create a new DNS zone mapping this domain
        /// name to an internal IP address and a forwarding rule mapping that address
        /// to the service attachment.
        pub cluster_hostname: std::string::String,

        /// Output only. Service attachment URI for the workstation cluster. The
        /// service attachment is created when private endpoint is enabled. To access
        /// workstations in the workstation cluster, configure access to the managed
        /// service using [Private Service
        /// Connect](https://cloud.google.com/vpc/docs/configure-private-service-connect-services).
        pub service_attachment_uri: std::string::String,

        /// Optional. Additional projects that are allowed to attach to the
        /// workstation cluster's service attachment. By default, the workstation
        /// cluster's project and the VPC host project (if different) are allowed.
        pub allowed_projects: std::vec::Vec<std::string::String>,

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

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

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

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

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

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

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

    /// Configuration options for a custom domain.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct DomainConfig {
        /// Immutable. Domain used by Workstations for HTTP ingress.
        pub domain: std::string::String,

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

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

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

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

    /// Configuration options for Cluster HTTP Gateway.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct GatewayConfig {
        /// Optional. Whether HTTP/2 is enabled for this workstation cluster.
        /// Defaults to false.
        pub http2_enabled: bool,

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

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

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

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

/// A workstation configuration resource in the Cloud Workstations API.
///
/// Workstation configurations act as templates for workstations. The workstation
/// configuration defines details such as the workstation virtual machine (VM)
/// instance type, persistent storage, container image defining environment,
/// which IDE or Code Editor to use, and more. Administrators and platform teams
/// can also use [Identity and Access Management
/// (IAM)](https://cloud.google.com/iam/docs/overview) rules to grant access to
/// teams or to individual developers.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct WorkstationConfig {
    /// Identifier. Full name of this workstation configuration.
    pub name: std::string::String,

    /// Optional. Human-readable name for this workstation configuration.
    pub display_name: std::string::String,

    /// Output only. A system-assigned unique identifier for this workstation
    /// configuration.
    pub uid: std::string::String,

    /// Output only. Indicates whether this workstation configuration is currently
    /// being updated to match its intended state.
    pub reconciling: bool,

    /// Optional. Client-specified annotations.
    pub annotations: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional.
    /// [Labels](https://cloud.google.com/workstations/docs/label-resources) that
    /// are applied to the workstation configuration and that are also propagated
    /// to the underlying Compute Engine resources.
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. Time when this workstation configuration was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Time when this workstation configuration was most recently
    /// updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Time when this workstation configuration was soft-deleted.
    pub delete_time: std::option::Option<wkt::Timestamp>,

    /// Optional. Checksum computed by the server. May be sent on update and delete
    /// requests to make sure that the client has an up-to-date value before
    /// proceeding.
    pub etag: std::string::String,

    /// Optional. Number of seconds to wait before automatically stopping a
    /// workstation after it last received user traffic.
    ///
    /// A value of `"0s"` indicates that Cloud Workstations VMs created with this
    /// configuration should never time out due to idleness.
    /// Provide
    /// [duration](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#duration)
    /// terminated by `s` for seconds—for example, `"7200s"` (2 hours).
    /// The default is `"1200s"` (20 minutes).
    pub idle_timeout: std::option::Option<wkt::Duration>,

    /// Optional. Number of seconds that a workstation can run until it is
    /// automatically shut down. We recommend that workstations be shut down daily
    /// to reduce costs and so that security updates can be applied upon restart.
    /// The
    /// [idle_timeout][google.cloud.workstations.v1.WorkstationConfig.idle_timeout]
    /// and
    /// [running_timeout][google.cloud.workstations.v1.WorkstationConfig.running_timeout]
    /// fields are independent of each other. Note that the
    /// [running_timeout][google.cloud.workstations.v1.WorkstationConfig.running_timeout]
    /// field shuts down VMs after the specified time, regardless of whether or not
    /// the VMs are idle.
    ///
    /// Provide duration terminated by `s` for seconds—for example, `"54000s"`
    /// (15 hours). Defaults to `"43200s"` (12 hours). A value of `"0s"` indicates
    /// that workstations using this configuration should never time out. If
    /// [encryption_key][google.cloud.workstations.v1.WorkstationConfig.encryption_key]
    /// is set, it must be greater than `"0s"` and less than
    /// `"86400s"` (24 hours).
    ///
    /// Warning: A value of `"0s"` indicates that Cloud Workstations VMs created
    /// with this configuration have no maximum running time. This is strongly
    /// discouraged because you incur costs and will not pick up security updates.
    ///
    /// [google.cloud.workstations.v1.WorkstationConfig.encryption_key]: crate::model::WorkstationConfig::encryption_key
    /// [google.cloud.workstations.v1.WorkstationConfig.idle_timeout]: crate::model::WorkstationConfig::idle_timeout
    /// [google.cloud.workstations.v1.WorkstationConfig.running_timeout]: crate::model::WorkstationConfig::running_timeout
    pub running_timeout: std::option::Option<wkt::Duration>,

    /// Optional. Maximum number of workstations under this configuration a user
    /// can have `workstations.workstation.use` permission on.
    ///
    /// Only enforced on CreateWorkstation API calls on the user issuing the API
    /// request. Can be overridden by:
    ///
    /// - granting a user
    ///   workstations.workstationConfigs.exemptMaxUsableWorkstationLimit permission,
    ///   or
    /// - having a user with that permission create a workstation and
    ///   granting another user `workstations.workstation.use` permission on
    ///   that workstation.
    ///
    /// If not specified, defaults to `0`, which indicates unlimited.
    pub max_usable_workstations: i32,

    /// Optional. Runtime host for the workstation.
    pub host: std::option::Option<crate::model::workstation_config::Host>,

    /// Optional. Directories to persist across workstation sessions.
    pub persistent_directories:
        std::vec::Vec<crate::model::workstation_config::PersistentDirectory>,

    /// Optional. Ephemeral directories which won't persist across workstation
    /// sessions.
    pub ephemeral_directories: std::vec::Vec<crate::model::workstation_config::EphemeralDirectory>,

    /// Optional. Container that runs upon startup for each workstation using this
    /// workstation configuration.
    pub container: std::option::Option<crate::model::workstation_config::Container>,

    /// Immutable. Encrypts resources of this workstation configuration using a
    /// customer-managed encryption key (CMEK).
    ///
    /// If specified, the boot disk of the Compute Engine instance and the
    /// persistent disk are encrypted using this encryption key. If
    /// this field is not set, the disks are encrypted using a generated
    /// key. Customer-managed encryption keys do not protect disk metadata.
    ///
    /// If the customer-managed encryption key is rotated, when the workstation
    /// instance is stopped, the system attempts to recreate the
    /// persistent disk with the new version of the key. Be sure to keep
    /// older versions of the key until the persistent disk is recreated.
    /// Otherwise, data on the persistent disk might be lost.
    ///
    /// If the encryption key is revoked, the workstation session automatically
    /// stops within 7 hours.
    ///
    /// Immutable after the workstation configuration is created.
    pub encryption_key:
        std::option::Option<crate::model::workstation_config::CustomerEncryptionKey>,

    /// Optional. Readiness checks to perform when starting a workstation using
    /// this workstation configuration. Mark a workstation as running only after
    /// all specified readiness checks return 200 status codes.
    pub readiness_checks: std::vec::Vec<crate::model::workstation_config::ReadinessCheck>,

    /// Optional. Immutable. Specifies the zones used to replicate the VM and disk
    /// resources within the region. If set, exactly two zones within the
    /// workstation cluster's region must be specified—for example,
    /// `['us-central1-a', 'us-central1-f']`. If this field is empty, two default
    /// zones within the region are used.
    ///
    /// Immutable after the workstation configuration is created.
    pub replica_zones: std::vec::Vec<std::string::String>,

    /// Output only. Whether this workstation configuration is in degraded mode, in
    /// which case it may require user action to restore full functionality. The
    /// [conditions][google.cloud.workstations.v1.WorkstationConfig.conditions]
    /// field contains detailed information about the status of the configuration.
    ///
    /// [google.cloud.workstations.v1.WorkstationConfig.conditions]: crate::model::WorkstationConfig::conditions
    pub degraded: bool,

    /// Output only. Status conditions describing the workstation configuration's
    /// current state.
    pub conditions: std::vec::Vec<google_cloud_rpc::model::Status>,

    /// Optional. Whether to enable Linux `auditd` logging on the workstation. When
    /// enabled, a
    /// [service_account][google.cloud.workstations.v1.WorkstationConfig.Host.GceInstance.service_account]
    /// must also be specified that has `roles/logging.logWriter` and
    /// `roles/monitoring.metricWriter` on the project. Operating system audit
    /// logging is distinct from [Cloud Audit
    /// Logs](https://cloud.google.com/workstations/docs/audit-logging) and
    /// [Container output
    /// logging](https://cloud.google.com/workstations/docs/container-output-logging#overview).
    /// Operating system audit logs are available in the
    /// [Cloud Logging](https://cloud.google.com/logging/docs) console by querying:
    ///
    /// ```norust
    /// resource.type="gce_instance"
    /// log_name:"/logs/linux-auditd"
    /// ```
    ///
    /// [google.cloud.workstations.v1.WorkstationConfig.Host.GceInstance.service_account]: crate::model::workstation_config::host::GceInstance::service_account
    pub enable_audit_agent: bool,

    /// Optional. Disables support for plain TCP connections in the workstation.
    /// By default the service supports TCP connections through a websocket relay.
    /// Setting this option to true disables that relay, which prevents the usage
    /// of services that require plain TCP connections, such as SSH.
    /// When enabled, all communication must occur over HTTPS or WSS.
    pub disable_tcp_connections: bool,

    /// Optional. A list of
    /// [PortRange][google.cloud.workstations.v1.WorkstationConfig.PortRange]s
    /// specifying single ports or ranges of ports that are externally accessible
    /// in the workstation. Allowed ports must be one of 22, 80, or within range
    /// 1024-65535. If not specified defaults to ports 22, 80, and ports
    /// 1024-65535.
    ///
    /// [google.cloud.workstations.v1.WorkstationConfig.PortRange]: crate::model::workstation_config::PortRange
    pub allowed_ports: std::vec::Vec<crate::model::workstation_config::PortRange>,

    /// Optional. Grant creator of a workstation `roles/workstations.policyAdmin`
    /// role along with `roles/workstations.user` role on the workstation created
    /// by them. This allows workstation users to share access to either their
    /// entire workstation, or individual ports. Defaults to false.
    pub grant_workstation_admin_role_on_create: bool,

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

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

    /// Sets the value of [name][crate::model::WorkstationConfig::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationConfig;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let workstation_cluster_id = "workstation_cluster_id";
    /// # let workstation_config_id = "workstation_config_id";
    /// let x = WorkstationConfig::new().set_name(format!("projects/{project_id}/locations/{location_id}/workstationClusters/{workstation_cluster_id}/workstationConfigs/{workstation_config_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 [display_name][crate::model::WorkstationConfig::display_name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationConfig;
    /// let x = WorkstationConfig::new().set_display_name("example");
    /// ```
    pub fn set_display_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.display_name = v.into();
        self
    }

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

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

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

    /// Sets the value of [labels][crate::model::WorkstationConfig::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationConfig;
    /// let x = WorkstationConfig::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::WorkstationConfig::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationConfig;
    /// use wkt::Timestamp;
    /// let x = WorkstationConfig::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::WorkstationConfig::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationConfig;
    /// use wkt::Timestamp;
    /// let x = WorkstationConfig::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = WorkstationConfig::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::WorkstationConfig::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationConfig;
    /// use wkt::Timestamp;
    /// let x = WorkstationConfig::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::WorkstationConfig::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationConfig;
    /// use wkt::Timestamp;
    /// let x = WorkstationConfig::new().set_or_clear_update_time(Some(Timestamp::default()/* use setters */));
    /// let x = WorkstationConfig::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 [delete_time][crate::model::WorkstationConfig::delete_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::WorkstationConfig;
    /// use wkt::Timestamp;
    /// let x = WorkstationConfig::new().set_delete_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_delete_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.delete_time = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Runtime host for a workstation.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Host {
        /// Type of host to be used for the workstation's runtime.
        pub config: std::option::Option<crate::model::workstation_config::host::Config>,

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

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

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

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

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

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

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

        /// A runtime using a Compute Engine instance.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct GceInstance {
            /// Optional. The type of machine to use for VM instances—for example,
            /// `"e2-standard-4"`. For more information about machine types that
            /// Cloud Workstations supports, see the list of
            /// [available machine
            /// types](https://cloud.google.com/workstations/docs/available-machine-types).
            pub machine_type: std::string::String,

            /// Optional. The email address of the service account for Cloud
            /// Workstations VMs created with this configuration. When specified, be
            /// sure that the service account has `logging.logEntries.create` and
            /// `monitoring.timeSeries.create` permissions on the project so it can
            /// write logs out to Cloud Logging. If using a custom container image, the
            /// service account must have [Artifact Registry
            /// Reader](https://cloud.google.com/artifact-registry/docs/access-control#roles)
            /// permission to pull the specified image.
            ///
            /// If you as the administrator want to be able to `ssh` into the
            /// underlying VM, you need to set this value to a service account
            /// for which you have the `iam.serviceAccounts.actAs` permission.
            /// Conversely, if you don't want anyone to be able to `ssh` into the
            /// underlying VM, use a service account where no one has that
            /// permission.
            ///
            /// If not set, VMs run with a service account provided by the
            /// Cloud Workstations service, and the image must be publicly
            /// accessible.
            pub service_account: std::string::String,

            /// Optional. Scopes to grant to the
            /// [service_account][google.cloud.workstations.v1.WorkstationConfig.Host.GceInstance.service_account].
            /// When specified, users of workstations under this configuration must
            /// have `iam.serviceAccounts.actAs` on the service account.
            ///
            /// [google.cloud.workstations.v1.WorkstationConfig.Host.GceInstance.service_account]: crate::model::workstation_config::host::GceInstance::service_account
            pub service_account_scopes: std::vec::Vec<std::string::String>,

            /// Optional. Network tags to add to the Compute Engine VMs backing the
            /// workstations. This option applies
            /// [network
            /// tags](https://cloud.google.com/vpc/docs/add-remove-network-tags) to VMs
            /// created with this configuration. These network tags enable the creation
            /// of [firewall
            /// rules](https://cloud.google.com/workstations/docs/configure-firewall-rules).
            pub tags: std::vec::Vec<std::string::String>,

            /// Optional. The number of VMs that the system should keep idle so that
            /// new workstations can be started quickly for new users. Defaults to `0`
            /// in the API.
            pub pool_size: i32,

            /// Output only. Number of instances currently available in the pool for
            /// faster workstation startup.
            pub pooled_instances: i32,

            /// Optional. When set to true, disables public IP addresses for VMs. If
            /// you disable public IP addresses, you must set up Private Google Access
            /// or Cloud NAT on your network. If you use Private Google Access and you
            /// use `private.googleapis.com` or `restricted.googleapis.com` for
            /// Container Registry and Artifact Registry, make sure that you set
            /// up DNS records for domains `*.gcr.io` and `*.pkg.dev`.
            /// Defaults to false (VMs have public IP addresses).
            pub disable_public_ip_addresses: bool,

            /// Optional. Whether to enable nested virtualization on Cloud Workstations
            /// VMs created using this workstation configuration.
            ///
            /// Defaults to false.
            ///
            /// Nested virtualization lets you run virtual machine (VM) instances
            /// inside your workstation. Before enabling nested virtualization,
            /// consider the following important considerations. Cloud Workstations
            /// instances are subject to the [same restrictions as Compute Engine
            /// instances](https://cloud.google.com/compute/docs/instances/nested-virtualization/overview#restrictions):
            ///
            /// * **Organization policy**: projects, folders, or
            ///   organizations may be restricted from creating nested VMs if the
            ///   **Disable VM nested virtualization** constraint is enforced in
            ///   the organization policy. For more information, see the
            ///   Compute Engine section,
            ///   [Checking whether nested virtualization is
            ///   allowed](https://cloud.google.com/compute/docs/instances/nested-virtualization/managing-constraint#checking_whether_nested_virtualization_is_allowed).
            /// * **Performance**: nested VMs might experience a 10% or greater
            ///   decrease in performance for workloads that are CPU-bound and
            ///   possibly greater than a 10% decrease for workloads that are
            ///   input/output bound.
            /// * **Machine Type**: nested virtualization can only be enabled on
            ///   workstation configurations that specify a
            ///   [machine_type][google.cloud.workstations.v1.WorkstationConfig.Host.GceInstance.machine_type]
            ///   in the N1 or N2 machine series.
            ///
            /// [google.cloud.workstations.v1.WorkstationConfig.Host.GceInstance.machine_type]: crate::model::workstation_config::host::GceInstance::machine_type
            pub enable_nested_virtualization: bool,

            /// Optional. A set of Compute Engine Shielded instance options.
            pub shielded_instance_config: std::option::Option<
                crate::model::workstation_config::host::gce_instance::GceShieldedInstanceConfig,
            >,

            /// Optional. A set of Compute Engine Confidential VM instance options.
            pub confidential_instance_config: std::option::Option<
                crate::model::workstation_config::host::gce_instance::GceConfidentialInstanceConfig,
            >,

            /// Optional. The size of the boot disk for the VM in gigabytes (GB).
            /// The minimum boot disk size is `30` GB. Defaults to `50` GB.
            pub boot_disk_size_gb: i32,

            /// Optional. A list of the type and count of accelerator cards attached to
            /// the instance.
            pub accelerators:
                std::vec::Vec<crate::model::workstation_config::host::gce_instance::Accelerator>,

            /// Optional. A list of the boost configurations that workstations created
            /// using this workstation configuration are allowed to use. If specified,
            /// users will have the option to choose from the list of boost configs
            /// when starting a workstation.
            pub boost_configs:
                std::vec::Vec<crate::model::workstation_config::host::gce_instance::BoostConfig>,

            /// Optional. Whether to disable SSH access to the VM.
            pub disable_ssh: bool,

            /// Optional. Resource manager tags to be bound to this instance.
            /// Tag keys and values have the same definition as [resource manager
            /// tags](https://cloud.google.com/resource-manager/docs/tags/tags-overview).
            /// Keys must be in the format `tagKeys/{tag_key_id}`, and
            /// values are in the format `tagValues/456`.
            pub vm_tags: std::collections::HashMap<std::string::String, std::string::String>,

            /// Optional. Link to the startup script stored in Cloud Storage. This
            /// script will be run on the host workstation VM when the VM is created.
            /// The URI must be of the form gs://{bucket-name}/{object-name}. If
            /// specifying a startup script, the service account must have [Permission
            /// to access the bucket and script file in Cloud
            /// Storage](https://cloud.google.com/storage/docs/access-control/iam-permissions).
            /// Otherwise, the script must be publicly accessible.
            /// Note that the service regularly updates the OS version of the host VM,
            /// and it is the responsibility of the user to ensure the script stays
            /// compatible with the OS version.
            pub startup_script_uri: std::string::String,

            /// Optional. Custom metadata to apply to Compute Engine instances.
            pub instance_metadata:
                std::collections::HashMap<std::string::String, std::string::String>,

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

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

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

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

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

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

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

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

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

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

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

            /// Sets the value of [confidential_instance_config][crate::model::workstation_config::host::GceInstance::confidential_instance_config].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_workstations_v1::model::workstation_config::host::GceInstance;
            /// use google_cloud_workstations_v1::model::workstation_config::host::gce_instance::GceConfidentialInstanceConfig;
            /// let x = GceInstance::new().set_confidential_instance_config(GceConfidentialInstanceConfig::default()/* use setters */);
            /// ```
            pub fn set_confidential_instance_config<T>(mut self, v: T) -> Self
            where T: std::convert::Into<crate::model::workstation_config::host::gce_instance::GceConfidentialInstanceConfig>
            {
                self.confidential_instance_config = std::option::Option::Some(v.into());
                self
            }

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

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

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

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

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

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

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

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

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

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

            /// A set of Compute Engine Shielded instance options.
            #[derive(Clone, Default, PartialEq)]
            #[non_exhaustive]
            pub struct GceShieldedInstanceConfig {
                /// Optional. Whether the instance has Secure Boot enabled.
                pub enable_secure_boot: bool,

                /// Optional. Whether the instance has the vTPM enabled.
                pub enable_vtpm: bool,

                /// Optional. Whether the instance has integrity monitoring enabled.
                pub enable_integrity_monitoring: bool,

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

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

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

                /// Sets the value of [enable_vtpm][crate::model::workstation_config::host::gce_instance::GceShieldedInstanceConfig::enable_vtpm].
                ///
                /// # Example
                /// ```ignore,no_run
                /// # use google_cloud_workstations_v1::model::workstation_config::host::gce_instance::GceShieldedInstanceConfig;
                /// let x = GceShieldedInstanceConfig::new().set_enable_vtpm(true);
                /// ```
                pub fn set_enable_vtpm<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
                    self.enable_vtpm = v.into();
                    self
                }

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

            impl wkt::message::Message for GceShieldedInstanceConfig {
                fn typename() -> &'static str {
                    "type.googleapis.com/google.cloud.workstations.v1.WorkstationConfig.Host.GceInstance.GceShieldedInstanceConfig"
                }
            }

            /// A set of Compute Engine Confidential VM instance options.
            #[derive(Clone, Default, PartialEq)]
            #[non_exhaustive]
            pub struct GceConfidentialInstanceConfig {
                /// Optional. Whether the instance has confidential compute enabled.
                pub enable_confidential_compute: bool,

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

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

                /// Sets the value of [enable_confidential_compute][crate::model::workstation_config::host::gce_instance::GceConfidentialInstanceConfig::enable_confidential_compute].
                ///
                /// # Example
                /// ```ignore,no_run
                /// # use google_cloud_workstations_v1::model::workstation_config::host::gce_instance::GceConfidentialInstanceConfig;
                /// let x = GceConfidentialInstanceConfig::new().set_enable_confidential_compute(true);
                /// ```
                pub fn set_enable_confidential_compute<T: std::convert::Into<bool>>(
                    mut self,
                    v: T,
                ) -> Self {
                    self.enable_confidential_compute = v.into();
                    self
                }
            }

            impl wkt::message::Message for GceConfidentialInstanceConfig {
                fn typename() -> &'static str {
                    "type.googleapis.com/google.cloud.workstations.v1.WorkstationConfig.Host.GceInstance.GceConfidentialInstanceConfig"
                }
            }

            /// An accelerator card attached to the instance.
            #[derive(Clone, Default, PartialEq)]
            #[non_exhaustive]
            pub struct Accelerator {
                /// Optional. Type of accelerator resource to attach to the instance, for
                /// example,
                /// `"nvidia-tesla-p100"`.
                pub r#type: std::string::String,

                /// Optional. Number of accelerator cards exposed to the instance.
                pub count: i32,

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

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

                /// Sets the value of [r#type][crate::model::workstation_config::host::gce_instance::Accelerator::type].
                ///
                /// # Example
                /// ```ignore,no_run
                /// # use google_cloud_workstations_v1::model::workstation_config::host::gce_instance::Accelerator;
                /// let x = Accelerator::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 [count][crate::model::workstation_config::host::gce_instance::Accelerator::count].
                ///
                /// # Example
                /// ```ignore,no_run
                /// # use google_cloud_workstations_v1::model::workstation_config::host::gce_instance::Accelerator;
                /// let x = Accelerator::new().set_count(42);
                /// ```
                pub fn set_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
                    self.count = v.into();
                    self
                }
            }

            impl wkt::message::Message for Accelerator {
                fn typename() -> &'static str {
                    "type.googleapis.com/google.cloud.workstations.v1.WorkstationConfig.Host.GceInstance.Accelerator"
                }
            }

            /// A boost configuration is a set of resources that a workstation can use
            /// to increase its performance. If you specify a boost configuration, upon
            /// startup, workstation users can choose to use a VM provisioned under the
            /// boost config by passing the boost config ID in the start request. If
            /// the workstation user does not provide a boost config ID  in the start
            /// request, the system will choose a VM from the pool provisioned under
            /// the default config.
            #[derive(Clone, Default, PartialEq)]
            #[non_exhaustive]
            pub struct BoostConfig {
                /// Required. The ID to be used for the boost configuration.
                pub id: std::string::String,

                /// Optional. The type of machine that boosted VM instances will use—for
                /// example, `e2-standard-4`. For more information about machine types
                /// that Cloud Workstations supports, see the list of [available machine
                /// types](https://cloud.google.com/workstations/docs/available-machine-types).
                /// Defaults to `e2-standard-4`.
                pub machine_type: std::string::String,

                /// Optional. A list of the type and count of accelerator cards attached
                /// to the boost instance. Defaults to `none`.
                pub accelerators: std::vec::Vec<
                    crate::model::workstation_config::host::gce_instance::Accelerator,
                >,

                /// Optional. The size of the boot disk for the VM in gigabytes (GB).
                /// The minimum boot disk size is `30` GB. Defaults to `50` GB.
                pub boot_disk_size_gb: i32,

                /// Optional. Whether to enable nested virtualization on boosted Cloud
                /// Workstations VMs running using this boost configuration.
                ///
                /// Defaults to false.
                ///
                /// Nested virtualization lets you run virtual machine (VM) instances
                /// inside your workstation. Before enabling nested virtualization,
                /// consider the following important considerations. Cloud Workstations
                /// instances are subject to the [same restrictions as Compute Engine
                /// instances](https://cloud.google.com/compute/docs/instances/nested-virtualization/overview#restrictions):
                ///
                /// * **Organization policy**: projects, folders, or
                ///   organizations may be restricted from creating nested VMs if the
                ///   **Disable VM nested virtualization** constraint is enforced in
                ///   the organization policy. For more information, see the
                ///   Compute Engine section,
                ///   [Checking whether nested virtualization is
                ///   allowed](https://cloud.google.com/compute/docs/instances/nested-virtualization/managing-constraint#checking_whether_nested_virtualization_is_allowed).
                /// * **Performance**: nested VMs might experience a 10% or greater
                ///   decrease in performance for workloads that are CPU-bound and
                ///   possibly greater than a 10% decrease for workloads that are
                ///   input/output bound.
                /// * **Machine Type**: nested virtualization can only be enabled on
                ///   boost configurations that specify a
                ///   [machine_type][google.cloud.workstations.v1.WorkstationConfig.Host.GceInstance.BoostConfig.machine_type]
                ///   in the N1 or N2 machine series.
                ///
                /// [google.cloud.workstations.v1.WorkstationConfig.Host.GceInstance.BoostConfig.machine_type]: crate::model::workstation_config::host::gce_instance::BoostConfig::machine_type
                pub enable_nested_virtualization: bool,

                /// Optional. The number of boost VMs that the system should keep idle so
                /// that workstations can be boosted quickly. Defaults to `0`.
                pub pool_size: i32,

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

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

                /// Sets the value of [id][crate::model::workstation_config::host::gce_instance::BoostConfig::id].
                ///
                /// # Example
                /// ```ignore,no_run
                /// # use google_cloud_workstations_v1::model::workstation_config::host::gce_instance::BoostConfig;
                /// let x = BoostConfig::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 [machine_type][crate::model::workstation_config::host::gce_instance::BoostConfig::machine_type].
                ///
                /// # Example
                /// ```ignore,no_run
                /// # use google_cloud_workstations_v1::model::workstation_config::host::gce_instance::BoostConfig;
                /// let x = BoostConfig::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 [accelerators][crate::model::workstation_config::host::gce_instance::BoostConfig::accelerators].
                ///
                /// # Example
                /// ```ignore,no_run
                /// # use google_cloud_workstations_v1::model::workstation_config::host::gce_instance::BoostConfig;
                /// use google_cloud_workstations_v1::model::workstation_config::host::gce_instance::Accelerator;
                /// let x = BoostConfig::new()
                ///     .set_accelerators([
                ///         Accelerator::default()/* use setters */,
                ///         Accelerator::default()/* use (different) setters */,
                ///     ]);
                /// ```
                pub fn set_accelerators<T, V>(mut self, v: T) -> Self
                where
                    T: std::iter::IntoIterator<Item = V>,
                    V: std::convert::Into<
                            crate::model::workstation_config::host::gce_instance::Accelerator,
                        >,
                {
                    use std::iter::Iterator;
                    self.accelerators = v.into_iter().map(|i| i.into()).collect();
                    self
                }

                /// Sets the value of [boot_disk_size_gb][crate::model::workstation_config::host::gce_instance::BoostConfig::boot_disk_size_gb].
                ///
                /// # Example
                /// ```ignore,no_run
                /// # use google_cloud_workstations_v1::model::workstation_config::host::gce_instance::BoostConfig;
                /// let x = BoostConfig::new().set_boot_disk_size_gb(42);
                /// ```
                pub fn set_boot_disk_size_gb<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
                    self.boot_disk_size_gb = v.into();
                    self
                }

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

                /// Sets the value of [pool_size][crate::model::workstation_config::host::gce_instance::BoostConfig::pool_size].
                ///
                /// # Example
                /// ```ignore,no_run
                /// # use google_cloud_workstations_v1::model::workstation_config::host::gce_instance::BoostConfig;
                /// let x = BoostConfig::new().set_pool_size(42);
                /// ```
                pub fn set_pool_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
                    self.pool_size = v.into();
                    self
                }
            }

            impl wkt::message::Message for BoostConfig {
                fn typename() -> &'static str {
                    "type.googleapis.com/google.cloud.workstations.v1.WorkstationConfig.Host.GceInstance.BoostConfig"
                }
            }
        }

        /// Type of host to be used for the workstation's runtime.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Config {
            /// Specifies a Compute Engine instance as the host.
            GceInstance(std::boxed::Box<crate::model::workstation_config::host::GceInstance>),
        }
    }

    /// A directory to persist across workstation sessions. Updates to this field
    /// will not update existing workstations and will only take effect on new
    /// workstations.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct PersistentDirectory {
        /// Optional. Location of this directory in the running workstation.
        pub mount_path: std::string::String,

        /// How a persistent directory should be implemented.
        pub directory_type: std::option::Option<
            crate::model::workstation_config::persistent_directory::DirectoryType,
        >,

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

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

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

        /// Sets the value of [directory_type][crate::model::workstation_config::PersistentDirectory::directory_type].
        ///
        /// Note that all the setters affecting `directory_type` are mutually
        /// exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_workstations_v1::model::workstation_config::PersistentDirectory;
        /// use google_cloud_workstations_v1::model::workstation_config::persistent_directory::GceRegionalPersistentDisk;
        /// let x = PersistentDirectory::new().set_directory_type(Some(
        ///     google_cloud_workstations_v1::model::workstation_config::persistent_directory::DirectoryType::GcePd(GceRegionalPersistentDisk::default().into())));
        /// ```
        pub fn set_directory_type<
            T: std::convert::Into<
                    std::option::Option<
                        crate::model::workstation_config::persistent_directory::DirectoryType,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.directory_type = v.into();
            self
        }

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

        /// Sets the value of [directory_type][crate::model::workstation_config::PersistentDirectory::directory_type]
        /// to hold a `GcePd`.
        ///
        /// Note that all the setters affecting `directory_type` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_workstations_v1::model::workstation_config::PersistentDirectory;
        /// use google_cloud_workstations_v1::model::workstation_config::persistent_directory::GceRegionalPersistentDisk;
        /// let x = PersistentDirectory::new().set_gce_pd(GceRegionalPersistentDisk::default()/* use setters */);
        /// assert!(x.gce_pd().is_some());
        /// assert!(x.gce_hd().is_none());
        /// ```
        pub fn set_gce_pd<T: std::convert::Into<std::boxed::Box<crate::model::workstation_config::persistent_directory::GceRegionalPersistentDisk>>>(mut self, v: T) -> Self{
            self.directory_type = std::option::Option::Some(
                crate::model::workstation_config::persistent_directory::DirectoryType::GcePd(
                    v.into(),
                ),
            );
            self
        }

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

        /// Sets the value of [directory_type][crate::model::workstation_config::PersistentDirectory::directory_type]
        /// to hold a `GceHd`.
        ///
        /// Note that all the setters affecting `directory_type` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_workstations_v1::model::workstation_config::PersistentDirectory;
        /// use google_cloud_workstations_v1::model::workstation_config::persistent_directory::GceHyperdiskBalancedHighAvailability;
        /// let x = PersistentDirectory::new().set_gce_hd(GceHyperdiskBalancedHighAvailability::default()/* use setters */);
        /// assert!(x.gce_hd().is_some());
        /// assert!(x.gce_pd().is_none());
        /// ```
        pub fn set_gce_hd<T: std::convert::Into<std::boxed::Box<crate::model::workstation_config::persistent_directory::GceHyperdiskBalancedHighAvailability>>>(mut self, v: T) -> Self{
            self.directory_type = std::option::Option::Some(
                crate::model::workstation_config::persistent_directory::DirectoryType::GceHd(
                    v.into(),
                ),
            );
            self
        }
    }

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

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

        /// A Persistent Directory backed by a Compute Engine regional persistent
        /// disk. The
        /// [persistent_directories][google.cloud.workstations.v1.WorkstationConfig.persistent_directories]
        /// field is repeated, but it may contain only one entry. It creates a
        /// [persistent
        /// disk](https://cloud.google.com/compute/docs/disks/persistent-disks) that
        /// mounts to the workstation VM at `/home` when the session starts and
        /// detaches when the session ends. If this field is empty, workstations
        /// created with this configuration do not have a persistent home
        /// directory.
        ///
        /// [google.cloud.workstations.v1.WorkstationConfig.persistent_directories]: crate::model::WorkstationConfig::persistent_directories
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct GceRegionalPersistentDisk {

            /// Optional. The GB capacity of a persistent home directory for each
            /// workstation created with this configuration. Must be empty if
            /// [source_snapshot][google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceRegionalPersistentDisk.source_snapshot]
            /// is set.
            ///
            /// Valid values are `10`, `50`, `100`, `200`, `500`, or `1000`.
            /// Defaults to `200`. If less than `200` GB, the
            /// [disk_type][google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceRegionalPersistentDisk.disk_type]
            /// must be
            /// `"pd-balanced"` or `"pd-ssd"`.
            ///
            /// [google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceRegionalPersistentDisk.disk_type]: crate::model::workstation_config::persistent_directory::GceRegionalPersistentDisk::disk_type
            /// [google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceRegionalPersistentDisk.source_snapshot]: crate::model::workstation_config::persistent_directory::GceRegionalPersistentDisk::source_snapshot
            pub size_gb: i32,

            /// Optional. Maximum size in GB to which this persistent directory can be
            /// resized. Defaults to unlimited if not set.
            pub max_size_gb: i32,

            /// Optional. Type of file system that the disk should be formatted with.
            /// The workstation image must support this file system type. Must be empty
            /// if
            /// [source_snapshot][google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceRegionalPersistentDisk.source_snapshot]
            /// is set. Defaults to `"ext4"`.
            ///
            /// [google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceRegionalPersistentDisk.source_snapshot]: crate::model::workstation_config::persistent_directory::GceRegionalPersistentDisk::source_snapshot
            pub fs_type: std::string::String,

            /// Optional. The [type of the persistent
            /// disk](https://cloud.google.com/compute/docs/disks#disk-types) for the
            /// home directory. Defaults to `"pd-standard"`.
            pub disk_type: std::string::String,

            /// Optional. Name of the snapshot to use as the source for the disk. If
            /// set,
            /// [size_gb][google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceRegionalPersistentDisk.size_gb]
            /// and
            /// [fs_type][google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceRegionalPersistentDisk.fs_type]
            /// must be empty. Must be formatted as ext4 file system with no
            /// partitions.
            ///
            /// [google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceRegionalPersistentDisk.fs_type]: crate::model::workstation_config::persistent_directory::GceRegionalPersistentDisk::fs_type
            /// [google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceRegionalPersistentDisk.size_gb]: crate::model::workstation_config::persistent_directory::GceRegionalPersistentDisk::size_gb
            pub source_snapshot: std::string::String,

            /// Optional. Whether the persistent disk should be deleted when the
            /// workstation is deleted. Valid values are `DELETE` and `RETAIN`.
            /// Defaults to `DELETE`.
            pub reclaim_policy: crate::model::workstation_config::persistent_directory::gce_regional_persistent_disk::ReclaimPolicy,

            /// Optional. Number of seconds to wait after initially creating or
            /// subsequently shutting down the workstation before converting its disk
            /// into a snapshot. This generally saves costs at the expense of greater
            /// startup time on next workstation start, as the service will need to
            /// create a disk from the archival snapshot.
            ///
            /// A value of `"0s"` indicates that the disk will never be archived.
            pub archive_timeout: std::option::Option<wkt::Duration>,

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

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

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

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

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

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

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

            /// Sets the value of [reclaim_policy][crate::model::workstation_config::persistent_directory::GceRegionalPersistentDisk::reclaim_policy].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_workstations_v1::model::workstation_config::persistent_directory::GceRegionalPersistentDisk;
            /// use google_cloud_workstations_v1::model::workstation_config::persistent_directory::gce_regional_persistent_disk::ReclaimPolicy;
            /// let x0 = GceRegionalPersistentDisk::new().set_reclaim_policy(ReclaimPolicy::Delete);
            /// let x1 = GceRegionalPersistentDisk::new().set_reclaim_policy(ReclaimPolicy::Retain);
            /// ```
            pub fn set_reclaim_policy<T: std::convert::Into<crate::model::workstation_config::persistent_directory::gce_regional_persistent_disk::ReclaimPolicy>>(mut self, v: T) -> Self{
                self.reclaim_policy = v.into();
                self
            }

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

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

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

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

            /// Value representing what should happen to the disk after the workstation
            /// is deleted.
            ///
            /// # 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 ReclaimPolicy {
                /// Do not use.
                Unspecified,
                /// Delete the persistent disk when deleting the workstation.
                Delete,
                /// Keep the persistent disk when deleting the workstation.
                /// An administrator must manually delete the disk.
                Retain,
                /// If set, the enum was initialized with an unknown value.
                ///
                /// Applications can examine the value using [ReclaimPolicy::value] or
                /// [ReclaimPolicy::name].
                UnknownValue(reclaim_policy::UnknownValue),
            }

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

            impl ReclaimPolicy {
                /// 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::Delete => std::option::Option::Some(1),
                        Self::Retain => 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("RECLAIM_POLICY_UNSPECIFIED")
                        }
                        Self::Delete => std::option::Option::Some("DELETE"),
                        Self::Retain => std::option::Option::Some("RETAIN"),
                        Self::UnknownValue(u) => u.0.name(),
                    }
                }
            }

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

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

            impl std::convert::From<&str> for ReclaimPolicy {
                fn from(value: &str) -> Self {
                    use std::string::ToString;
                    match value {
                        "RECLAIM_POLICY_UNSPECIFIED" => Self::Unspecified,
                        "DELETE" => Self::Delete,
                        "RETAIN" => Self::Retain,
                        _ => Self::UnknownValue(reclaim_policy::UnknownValue(
                            wkt::internal::UnknownEnumValue::String(value.to_string()),
                        )),
                    }
                }
            }

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

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

        /// A Persistent Directory backed by a Compute Engine
        /// [Hyperdisk Balanced High Availability
        /// Disk](https://cloud.google.com/compute/docs/disks/hd-types/hyperdisk-balanced-ha).
        /// This is a high-availability block storage solution that offers a balance
        /// between performance and cost for most general-purpose workloads.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct GceHyperdiskBalancedHighAvailability {

            /// Optional. The GB capacity of a persistent home directory for each
            /// workstation created with this configuration. Must be empty if
            /// [source_snapshot][google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceHyperdiskBalancedHighAvailability.source_snapshot]
            /// is set.
            ///
            /// Valid values are `10`, `50`, `100`, `200`, `500`, or `1000`.
            /// Defaults to `200`.
            ///
            /// [google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceHyperdiskBalancedHighAvailability.source_snapshot]: crate::model::workstation_config::persistent_directory::GceHyperdiskBalancedHighAvailability::source_snapshot
            pub size_gb: i32,

            /// Optional. Maximum size in GB to which this persistent directory can be
            /// resized. Defaults to unlimited if not set.
            pub max_size_gb: i32,

            /// Optional. Name of the snapshot to use as the source for the disk. If
            /// set,
            /// [size_gb][google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceHyperdiskBalancedHighAvailability.size_gb]
            /// must be empty. Must be formatted as ext4 file system with no
            /// partitions.
            ///
            /// [google.cloud.workstations.v1.WorkstationConfig.PersistentDirectory.GceHyperdiskBalancedHighAvailability.size_gb]: crate::model::workstation_config::persistent_directory::GceHyperdiskBalancedHighAvailability::size_gb
            pub source_snapshot: std::string::String,

            /// Optional. Whether the persistent disk should be deleted when the
            /// workstation is deleted. Valid values are `DELETE` and `RETAIN`.
            /// Defaults to `DELETE`.
            pub reclaim_policy: crate::model::workstation_config::persistent_directory::gce_hyperdisk_balanced_high_availability::ReclaimPolicy,

            /// Optional. Number of seconds to wait after initially creating or
            /// subsequently shutting down the workstation before converting its disk
            /// into a snapshot. This generally saves costs at the expense of greater
            /// startup time on next workstation start, as the service will need to
            /// create a disk from the archival snapshot.
            ///
            /// A value of `"0s"` indicates that the disk will never be archived.
            pub archive_timeout: std::option::Option<wkt::Duration>,

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

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

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

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

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

            /// Sets the value of [reclaim_policy][crate::model::workstation_config::persistent_directory::GceHyperdiskBalancedHighAvailability::reclaim_policy].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_workstations_v1::model::workstation_config::persistent_directory::GceHyperdiskBalancedHighAvailability;
            /// use google_cloud_workstations_v1::model::workstation_config::persistent_directory::gce_hyperdisk_balanced_high_availability::ReclaimPolicy;
            /// let x0 = GceHyperdiskBalancedHighAvailability::new().set_reclaim_policy(ReclaimPolicy::Delete);
            /// let x1 = GceHyperdiskBalancedHighAvailability::new().set_reclaim_policy(ReclaimPolicy::Retain);
            /// ```
            pub fn set_reclaim_policy<T: std::convert::Into<crate::model::workstation_config::persistent_directory::gce_hyperdisk_balanced_high_availability::ReclaimPolicy>>(mut self, v: T) -> Self{
                self.reclaim_policy = v.into();
                self
            }

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

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

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

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

            /// Value representing what should happen to the disk after the workstation
            /// is deleted.
            ///
            /// # 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 ReclaimPolicy {
                /// Do not use.
                Unspecified,
                /// Delete the persistent disk when deleting the workstation.
                Delete,
                /// Keep the persistent disk when deleting the workstation.
                /// An administrator must manually delete the disk.
                Retain,
                /// If set, the enum was initialized with an unknown value.
                ///
                /// Applications can examine the value using [ReclaimPolicy::value] or
                /// [ReclaimPolicy::name].
                UnknownValue(reclaim_policy::UnknownValue),
            }

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

            impl ReclaimPolicy {
                /// 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::Delete => std::option::Option::Some(1),
                        Self::Retain => 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("RECLAIM_POLICY_UNSPECIFIED")
                        }
                        Self::Delete => std::option::Option::Some("DELETE"),
                        Self::Retain => std::option::Option::Some("RETAIN"),
                        Self::UnknownValue(u) => u.0.name(),
                    }
                }
            }

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

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

            impl std::convert::From<&str> for ReclaimPolicy {
                fn from(value: &str) -> Self {
                    use std::string::ToString;
                    match value {
                        "RECLAIM_POLICY_UNSPECIFIED" => Self::Unspecified,
                        "DELETE" => Self::Delete,
                        "RETAIN" => Self::Retain,
                        _ => Self::UnknownValue(reclaim_policy::UnknownValue(
                            wkt::internal::UnknownEnumValue::String(value.to_string()),
                        )),
                    }
                }
            }

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

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

        /// How a persistent directory should be implemented.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum DirectoryType {
            /// A PersistentDirectory backed by a Compute Engine persistent disk.
            GcePd(std::boxed::Box<crate::model::workstation_config::persistent_directory::GceRegionalPersistentDisk>),
            /// A PersistentDirectory backed by a Compute Engine hyperdisk high
            /// availability disk.
            GceHd(std::boxed::Box<crate::model::workstation_config::persistent_directory::GceHyperdiskBalancedHighAvailability>),
        }
    }

    /// An ephemeral directory which won't persist across workstation sessions. It
    /// is freshly created on every workstation start operation.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct EphemeralDirectory {
        /// Required. Location of this directory in the running workstation.
        pub mount_path: std::string::String,

        /// How an ephemeral directory should be implemented.
        pub directory_type: std::option::Option<
            crate::model::workstation_config::ephemeral_directory::DirectoryType,
        >,

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

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

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

        /// Sets the value of [directory_type][crate::model::workstation_config::EphemeralDirectory::directory_type].
        ///
        /// Note that all the setters affecting `directory_type` are mutually
        /// exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_workstations_v1::model::workstation_config::EphemeralDirectory;
        /// use google_cloud_workstations_v1::model::workstation_config::ephemeral_directory::GcePersistentDisk;
        /// let x = EphemeralDirectory::new().set_directory_type(Some(
        ///     google_cloud_workstations_v1::model::workstation_config::ephemeral_directory::DirectoryType::GcePd(GcePersistentDisk::default().into())));
        /// ```
        pub fn set_directory_type<
            T: std::convert::Into<
                    std::option::Option<
                        crate::model::workstation_config::ephemeral_directory::DirectoryType,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.directory_type = v.into();
            self
        }

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

        /// Sets the value of [directory_type][crate::model::workstation_config::EphemeralDirectory::directory_type]
        /// to hold a `GcePd`.
        ///
        /// Note that all the setters affecting `directory_type` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_workstations_v1::model::workstation_config::EphemeralDirectory;
        /// use google_cloud_workstations_v1::model::workstation_config::ephemeral_directory::GcePersistentDisk;
        /// let x = EphemeralDirectory::new().set_gce_pd(GcePersistentDisk::default()/* use setters */);
        /// assert!(x.gce_pd().is_some());
        /// ```
        pub fn set_gce_pd<
            T: std::convert::Into<
                    std::boxed::Box<
                        crate::model::workstation_config::ephemeral_directory::GcePersistentDisk,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.directory_type = std::option::Option::Some(
                crate::model::workstation_config::ephemeral_directory::DirectoryType::GcePd(
                    v.into(),
                ),
            );
            self
        }
    }

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

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

        /// An EphemeralDirectory is backed by a Compute Engine persistent disk.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct GcePersistentDisk {
            /// Optional. Type of the disk to use. Defaults to `"pd-standard"`.
            pub disk_type: std::string::String,

            /// Optional. Name of the snapshot to use as the source for the disk. Must
            /// be empty if
            /// [source_image][google.cloud.workstations.v1.WorkstationConfig.EphemeralDirectory.GcePersistentDisk.source_image]
            /// is set. Must be empty if
            /// [read_only][google.cloud.workstations.v1.WorkstationConfig.EphemeralDirectory.GcePersistentDisk.read_only]
            /// is false. Updating
            /// [source_snapshot][google.cloud.workstations.v1.WorkstationConfig.EphemeralDirectory.GcePersistentDisk.source_snapshot]
            /// will update content in the ephemeral directory after the workstation is
            /// restarted.
            ///
            /// Only file systems supported by Container-Optimized OS (COS)
            /// are explicitly supported. For a list of supported file systems, see
            /// [the filesystems available in Container-Optimized
            /// OS](https://cloud.google.com/container-optimized-os/docs/concepts/supported-filesystems).
            ///
            /// This field is mutable.
            ///
            /// [google.cloud.workstations.v1.WorkstationConfig.EphemeralDirectory.GcePersistentDisk.read_only]: crate::model::workstation_config::ephemeral_directory::GcePersistentDisk::read_only
            /// [google.cloud.workstations.v1.WorkstationConfig.EphemeralDirectory.GcePersistentDisk.source_image]: crate::model::workstation_config::ephemeral_directory::GcePersistentDisk::source_image
            /// [google.cloud.workstations.v1.WorkstationConfig.EphemeralDirectory.GcePersistentDisk.source_snapshot]: crate::model::workstation_config::ephemeral_directory::GcePersistentDisk::source_snapshot
            pub source_snapshot: std::string::String,

            /// Optional. Name of the disk image to use as the source for the disk.
            /// Must be empty if
            /// [source_snapshot][google.cloud.workstations.v1.WorkstationConfig.EphemeralDirectory.GcePersistentDisk.source_snapshot]
            /// is set. Updating
            /// [source_image][google.cloud.workstations.v1.WorkstationConfig.EphemeralDirectory.GcePersistentDisk.source_image]
            /// will update content in the ephemeral directory after the workstation is
            /// restarted.
            ///
            /// Only file systems supported by Container-Optimized OS (COS)
            /// are explicitly supported. For a list of supported file systems, please
            /// refer to the [COS
            /// documentation](https://cloud.google.com/container-optimized-os/docs/concepts/supported-filesystems).
            ///
            /// This field is mutable.
            ///
            /// [google.cloud.workstations.v1.WorkstationConfig.EphemeralDirectory.GcePersistentDisk.source_image]: crate::model::workstation_config::ephemeral_directory::GcePersistentDisk::source_image
            /// [google.cloud.workstations.v1.WorkstationConfig.EphemeralDirectory.GcePersistentDisk.source_snapshot]: crate::model::workstation_config::ephemeral_directory::GcePersistentDisk::source_snapshot
            pub source_image: std::string::String,

            /// Optional. Whether the disk is read only. If true, the disk may be
            /// shared by multiple VMs and
            /// [source_snapshot][google.cloud.workstations.v1.WorkstationConfig.EphemeralDirectory.GcePersistentDisk.source_snapshot]
            /// must be set.
            ///
            /// [google.cloud.workstations.v1.WorkstationConfig.EphemeralDirectory.GcePersistentDisk.source_snapshot]: crate::model::workstation_config::ephemeral_directory::GcePersistentDisk::source_snapshot
            pub read_only: bool,

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

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

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

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

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

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

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

        /// How an ephemeral directory should be implemented.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum DirectoryType {
            /// An EphemeralDirectory backed by a Compute Engine persistent disk.
            GcePd(
                std::boxed::Box<
                    crate::model::workstation_config::ephemeral_directory::GcePersistentDisk,
                >,
            ),
        }
    }

    /// A Docker container.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Container {
        /// Optional. A Docker container image that defines a custom environment.
        ///
        /// Cloud Workstations provides a number of
        /// [preconfigured
        /// images](https://cloud.google.com/workstations/docs/preconfigured-base-images),
        /// but you can create your own
        /// [custom container
        /// images](https://cloud.google.com/workstations/docs/custom-container-images).
        /// If using a private image, the `host.gceInstance.serviceAccount` field
        /// must be specified in the workstation configuration.
        /// If using a custom container image, the service account must have
        /// [Artifact Registry
        /// Reader](https://cloud.google.com/artifact-registry/docs/access-control#roles)
        /// permission to pull the specified image. Otherwise, the image must be
        /// publicly accessible.
        pub image: std::string::String,

        /// Optional. If set, overrides the default ENTRYPOINT specified by the
        /// image.
        pub command: std::vec::Vec<std::string::String>,

        /// Optional. Arguments passed to the entrypoint.
        pub args: std::vec::Vec<std::string::String>,

        /// Optional. Environment variables passed to the container's entrypoint.
        pub env: std::collections::HashMap<std::string::String, std::string::String>,

        /// Optional. If set, overrides the default DIR specified by the image.
        pub working_dir: std::string::String,

        /// Optional. If set, overrides the USER specified in the image with the
        /// given uid.
        pub run_as_user: i32,

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

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

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

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

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

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

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

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

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

    /// A customer-managed encryption key (CMEK) for the Compute Engine
    /// resources of the associated workstation configuration. Specify the name of
    /// your Cloud KMS encryption key and the default service account.
    /// We recommend that you use a separate service account and follow
    /// [Cloud KMS best
    /// practices](https://cloud.google.com/kms/docs/separation-of-duties).
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct CustomerEncryptionKey {
        /// Immutable. The name of the Google Cloud KMS encryption key. For example,
        /// `"projects/PROJECT_ID/locations/REGION/keyRings/KEY_RING/cryptoKeys/KEY_NAME"`.
        /// The key must be in the same region as the workstation configuration.
        pub kms_key: std::string::String,

        /// Immutable. The service account to use with the specified
        /// KMS key. We recommend that you use a separate service account
        /// and follow KMS best practices. For more information, see
        /// [Separation of
        /// duties](https://cloud.google.com/kms/docs/separation-of-duties) and
        /// `gcloud kms keys add-iam-policy-binding`
        /// [`--member`](https://cloud.google.com/sdk/gcloud/reference/kms/keys/add-iam-policy-binding#--member).
        pub kms_key_service_account: std::string::String,

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

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

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

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

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

    /// A readiness check to be performed on a workstation.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ReadinessCheck {
        /// Optional. Path to which the request should be sent.
        pub path: std::string::String,

        /// Optional. Port to which the request should be sent.
        pub port: i32,

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

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

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

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

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

    /// A PortRange defines a range of ports. Both
    /// [first][google.cloud.workstations.v1.WorkstationConfig.PortRange.first] and
    /// [last][google.cloud.workstations.v1.WorkstationConfig.PortRange.last] are
    /// inclusive.
    /// To specify a single port, both
    /// [first][google.cloud.workstations.v1.WorkstationConfig.PortRange.first] and
    /// [last][google.cloud.workstations.v1.WorkstationConfig.PortRange.last]
    /// should be the same.
    ///
    /// [google.cloud.workstations.v1.WorkstationConfig.PortRange.first]: crate::model::workstation_config::PortRange::first
    /// [google.cloud.workstations.v1.WorkstationConfig.PortRange.last]: crate::model::workstation_config::PortRange::last
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct PortRange {
        /// Required. Starting port number for the current range of ports.
        /// Valid ports are 22, 80, and ports within the range 1024-65535.
        pub first: i32,

        /// Required. Ending port number for the current range of ports.
        /// Valid ports are 22, 80, and ports within the range 1024-65535.
        pub last: i32,

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

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

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

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

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

/// A single instance of a developer workstation with its own persistent storage.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Workstation {
    /// Identifier. Full name of this workstation.
    pub name: std::string::String,

    /// Optional. Human-readable name for this workstation.
    pub display_name: std::string::String,

    /// Output only. A system-assigned unique identifier for this workstation.
    pub uid: std::string::String,

    /// Output only. Indicates whether this workstation is currently being updated
    /// to match its intended state.
    pub reconciling: bool,

    /// Optional. Client-specified annotations.
    pub annotations: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional.
    /// [Labels](https://cloud.google.com/workstations/docs/label-resources) that
    /// are applied to the workstation and that are also propagated to the
    /// underlying Compute Engine resources.
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. Time when this workstation was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Time when this workstation was most recently updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Time when this workstation was most recently successfully
    /// started, regardless of the workstation's initial state.
    pub start_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Time when this workstation was soft-deleted.
    pub delete_time: std::option::Option<wkt::Timestamp>,

    /// Optional. Checksum computed by the server. May be sent on update and delete
    /// requests to make sure that the client has an up-to-date value before
    /// proceeding.
    pub etag: std::string::String,

    /// Optional. Directories to persist across workstation sessions.
    pub persistent_directories:
        std::vec::Vec<crate::model::workstation::WorkstationPersistentDirectory>,

    /// Output only. Current state of the workstation.
    pub state: crate::model::workstation::State,

    /// Output only. Host to which clients can send HTTPS traffic that will be
    /// received by the workstation. Authorized traffic will be received to the
    /// workstation as HTTP on port 80. To send traffic to a different port,
    /// clients may prefix the host with the destination port in the format
    /// `{port}-{host}`.
    pub host: std::string::String,

    /// Optional. Environment variables passed to the workstation container's
    /// entrypoint.
    pub env: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. The name of the Google Cloud KMS encryption key used to
    /// encrypt this workstation. The KMS key can only be configured in the
    /// WorkstationConfig. The expected format is
    /// `projects/*/locations/*/keyRings/*/cryptoKeys/*`.
    pub kms_key: std::string::String,

    /// Optional. The source workstation from which this workstation's persistent
    /// directories were cloned on creation.
    pub source_workstation: std::string::String,

    /// Optional. Output only. Runtime host for the workstation when in
    /// STATE_RUNNING.
    pub runtime_host: std::option::Option<crate::model::workstation::RuntimeHost>,

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

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

    /// Sets the value of [name][crate::model::Workstation::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::Workstation;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let workstation_cluster_id = "workstation_cluster_id";
    /// # let workstation_config_id = "workstation_config_id";
    /// # let workstation_id = "workstation_id";
    /// let x = Workstation::new().set_name(format!("projects/{project_id}/locations/{location_id}/workstationClusters/{workstation_cluster_id}/workstationConfigs/{workstation_config_id}/workstations/{workstation_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 [display_name][crate::model::Workstation::display_name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::Workstation;
    /// let x = Workstation::new().set_display_name("example");
    /// ```
    pub fn set_display_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.display_name = v.into();
        self
    }

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

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

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

    /// Sets the value of [labels][crate::model::Workstation::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::Workstation;
    /// let x = Workstation::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::Workstation::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::Workstation;
    /// use wkt::Timestamp;
    /// let x = Workstation::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::Workstation::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::Workstation;
    /// use wkt::Timestamp;
    /// let x = Workstation::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = Workstation::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::Workstation::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::Workstation;
    /// use wkt::Timestamp;
    /// let x = Workstation::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::Workstation::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::Workstation;
    /// use wkt::Timestamp;
    /// let x = Workstation::new().set_or_clear_update_time(Some(Timestamp::default()/* use setters */));
    /// let x = Workstation::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 [start_time][crate::model::Workstation::start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::Workstation;
    /// use wkt::Timestamp;
    /// let x = Workstation::new().set_start_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_start_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.start_time = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// A directory to persist across workstation sessions. Updates to this field
    /// will only take effect on this workstation after it is restarted.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct WorkstationPersistentDirectory {
        /// Optional. The mount path of the persistent directory.
        pub mount_path: std::string::String,

        /// Optional. Size of the persistent directory in GB. If specified in an
        /// update request, this is the desired size of the directory.
        pub size_gb: i32,

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

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

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

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

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

    /// Runtime host for the workstation.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct RuntimeHost {
        /// Type of host used by the workstation.
        pub host_type: std::option::Option<crate::model::workstation::runtime_host::HostType>,

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

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

        /// Sets the value of [host_type][crate::model::workstation::RuntimeHost::host_type].
        ///
        /// Note that all the setters affecting `host_type` are mutually
        /// exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_workstations_v1::model::workstation::RuntimeHost;
        /// use google_cloud_workstations_v1::model::workstation::runtime_host::GceInstanceHost;
        /// let x = RuntimeHost::new().set_host_type(Some(
        ///     google_cloud_workstations_v1::model::workstation::runtime_host::HostType::GceInstanceHost(GceInstanceHost::default().into())));
        /// ```
        pub fn set_host_type<
            T: std::convert::Into<
                    std::option::Option<crate::model::workstation::runtime_host::HostType>,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.host_type = v.into();
            self
        }

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

        /// Sets the value of [host_type][crate::model::workstation::RuntimeHost::host_type]
        /// to hold a `GceInstanceHost`.
        ///
        /// Note that all the setters affecting `host_type` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_workstations_v1::model::workstation::RuntimeHost;
        /// use google_cloud_workstations_v1::model::workstation::runtime_host::GceInstanceHost;
        /// let x = RuntimeHost::new().set_gce_instance_host(GceInstanceHost::default()/* use setters */);
        /// assert!(x.gce_instance_host().is_some());
        /// ```
        pub fn set_gce_instance_host<
            T: std::convert::Into<
                    std::boxed::Box<crate::model::workstation::runtime_host::GceInstanceHost>,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.host_type = std::option::Option::Some(
                crate::model::workstation::runtime_host::HostType::GceInstanceHost(v.into()),
            );
            self
        }
    }

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

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

        /// The Compute Engine instance host.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct GceInstanceHost {
            /// Optional. Output only. The name of the Compute Engine instance.
            pub name: std::string::String,

            /// Optional. Output only. The ID of the Compute Engine instance.
            pub id: std::string::String,

            /// Optional. Output only. The zone of the Compute Engine instance.
            pub zone: std::string::String,

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

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

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

            /// Sets the value of [id][crate::model::workstation::runtime_host::GceInstanceHost::id].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_workstations_v1::model::workstation::runtime_host::GceInstanceHost;
            /// let x = GceInstanceHost::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 [zone][crate::model::workstation::runtime_host::GceInstanceHost::zone].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_workstations_v1::model::workstation::runtime_host::GceInstanceHost;
            /// let x = GceInstanceHost::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
            }
        }

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

        /// Type of host used by the workstation.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum HostType {
            /// Specifies a Compute Engine instance as the host.
            GceInstanceHost(
                std::boxed::Box<crate::model::workstation::runtime_host::GceInstanceHost>,
            ),
        }
    }

    /// Whether a workstation is running and ready to receive user requests.
    ///
    /// # 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 {
        /// Do not use.
        Unspecified,
        /// The workstation is not yet ready to accept requests from users but will
        /// be soon.
        Starting,
        /// The workstation is ready to accept requests from users.
        Running,
        /// The workstation is being stopped.
        Stopping,
        /// The workstation is stopped and will not be able to receive requests until
        /// it is started.
        Stopped,
        /// 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::Starting => std::option::Option::Some(1),
                Self::Running => std::option::Option::Some(2),
                Self::Stopping => std::option::Option::Some(3),
                Self::Stopped => 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("STATE_UNSPECIFIED"),
                Self::Starting => std::option::Option::Some("STATE_STARTING"),
                Self::Running => std::option::Option::Some("STATE_RUNNING"),
                Self::Stopping => std::option::Option::Some("STATE_STOPPING"),
                Self::Stopped => std::option::Option::Some("STATE_STOPPED"),
                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::Starting,
                2 => Self::Running,
                3 => Self::Stopping,
                4 => Self::Stopped,
                _ => 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,
                "STATE_STARTING" => Self::Starting,
                "STATE_RUNNING" => Self::Running,
                "STATE_STOPPING" => Self::Stopping,
                "STATE_STOPPED" => Self::Stopped,
                _ => 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::Starting => serializer.serialize_i32(1),
                Self::Running => serializer.serialize_i32(2),
                Self::Stopping => serializer.serialize_i32(3),
                Self::Stopped => serializer.serialize_i32(4),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// Request message for GetWorkstationCluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetWorkstationClusterRequest {
    /// Required. Name of the requested resource.
    pub name: std::string::String,

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

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

    /// Sets the value of [name][crate::model::GetWorkstationClusterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::GetWorkstationClusterRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let workstation_cluster_id = "workstation_cluster_id";
    /// let x = GetWorkstationClusterRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/workstationClusters/{workstation_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 GetWorkstationClusterRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.workstations.v1.GetWorkstationClusterRequest"
    }
}

/// Request message for ListWorkstationClusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListWorkstationClustersRequest {
    /// Required. Parent resource name.
    pub parent: std::string::String,

    /// Optional. Maximum number of items to return.
    pub page_size: i32,

    /// Optional. next_page_token value returned from a previous List request, if
    /// any.
    pub page_token: std::string::String,

    /// Optional. Filter the WorkstationClusters to be listed. Possible filters are
    /// described in <https://google.aip.dev/160>.
    pub filter: std::string::String,

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

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

    /// Sets the value of [parent][crate::model::ListWorkstationClustersRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::ListWorkstationClustersRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// let x = ListWorkstationClustersRequest::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::ListWorkstationClustersRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::ListWorkstationClustersRequest;
    /// let x = ListWorkstationClustersRequest::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::ListWorkstationClustersRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::ListWorkstationClustersRequest;
    /// let x = ListWorkstationClustersRequest::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::ListWorkstationClustersRequest::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::ListWorkstationClustersRequest;
    /// let x = ListWorkstationClustersRequest::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
    }
}

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

/// Response message for ListWorkstationClusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListWorkstationClustersResponse {
    /// The requested workstation clusters.
    pub workstation_clusters: std::vec::Vec<crate::model::WorkstationCluster>,

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

    /// Unreachable resources.
    pub unreachable: std::vec::Vec<std::string::String>,

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

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

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

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

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

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

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

/// Message for creating a CreateWorkstationCluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateWorkstationClusterRequest {
    /// Required. Parent resource name.
    pub parent: std::string::String,

    /// Required. ID to use for the workstation cluster.
    pub workstation_cluster_id: std::string::String,

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

    /// Optional. If set, validate the request and preview the result, but do not
    /// actually apply it.
    pub validate_only: bool,

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

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

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

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

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

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

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

/// Request message for UpdateWorkstationCluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateWorkstationClusterRequest {
    /// Required. Workstation cluster to update.
    pub workstation_cluster: std::option::Option<crate::model::WorkstationCluster>,

    /// Required. Mask that specifies which fields in the workstation cluster
    /// should be updated.
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Optional. If set, validate the request and preview the result, but do not
    /// actually apply it.
    pub validate_only: bool,

    /// Optional. If set, and the workstation cluster is not found, a new
    /// workstation cluster will be created. In this situation, update_mask is
    /// ignored.
    pub allow_missing: bool,

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

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

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

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

    /// Sets the value of [update_mask][crate::model::UpdateWorkstationClusterRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::UpdateWorkstationClusterRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateWorkstationClusterRequest::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::UpdateWorkstationClusterRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::UpdateWorkstationClusterRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateWorkstationClusterRequest::new().set_or_clear_update_mask(Some(FieldMask::default()/* use setters */));
    /// let x = UpdateWorkstationClusterRequest::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 [validate_only][crate::model::UpdateWorkstationClusterRequest::validate_only].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::UpdateWorkstationClusterRequest;
    /// let x = UpdateWorkstationClusterRequest::new().set_validate_only(true);
    /// ```
    pub fn set_validate_only<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.validate_only = v.into();
        self
    }

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

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

/// Message for deleting a workstation cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteWorkstationClusterRequest {
    /// Required. Name of the workstation cluster to delete.
    pub name: std::string::String,

    /// Optional. If set, validate the request and preview the result, but do not
    /// apply it.
    pub validate_only: bool,

    /// Optional. If set, the request will be rejected if the latest version of the
    /// workstation cluster on the server does not have this ETag.
    pub etag: std::string::String,

    /// Optional. If set, any workstation configurations and workstations in the
    /// workstation cluster are also deleted. Otherwise, the request only
    /// works if the workstation cluster has no configurations or workstations.
    pub force: bool,

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

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

    /// Sets the value of [name][crate::model::DeleteWorkstationClusterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::DeleteWorkstationClusterRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let workstation_cluster_id = "workstation_cluster_id";
    /// let x = DeleteWorkstationClusterRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/workstationClusters/{workstation_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 [validate_only][crate::model::DeleteWorkstationClusterRequest::validate_only].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::DeleteWorkstationClusterRequest;
    /// let x = DeleteWorkstationClusterRequest::new().set_validate_only(true);
    /// ```
    pub fn set_validate_only<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.validate_only = v.into();
        self
    }

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

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

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

/// Request message for GetWorkstationConfig.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetWorkstationConfigRequest {
    /// Required. Name of the requested resource.
    pub name: std::string::String,

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

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

    /// Sets the value of [name][crate::model::GetWorkstationConfigRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::GetWorkstationConfigRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let workstation_cluster_id = "workstation_cluster_id";
    /// # let workstation_config_id = "workstation_config_id";
    /// let x = GetWorkstationConfigRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/workstationClusters/{workstation_cluster_id}/workstationConfigs/{workstation_config_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 GetWorkstationConfigRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.workstations.v1.GetWorkstationConfigRequest"
    }
}

/// Request message for ListWorkstationConfigs.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListWorkstationConfigsRequest {
    /// Required. Parent resource name.
    pub parent: std::string::String,

    /// Optional. Maximum number of items to return.
    pub page_size: i32,

    /// Optional. next_page_token value returned from a previous List request, if
    /// any.
    pub page_token: std::string::String,

    /// Optional. Filter the WorkstationConfigs to be listed. Possible filters are
    /// described in <https://google.aip.dev/160>.
    pub filter: std::string::String,

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

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

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

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

/// Response message for ListWorkstationConfigs.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListWorkstationConfigsResponse {
    /// The requested configs.
    pub workstation_configs: std::vec::Vec<crate::model::WorkstationConfig>,

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

    /// Unreachable resources.
    pub unreachable: std::vec::Vec<std::string::String>,

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

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

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

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

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

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

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

/// Request message for ListUsableWorkstationConfigs.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListUsableWorkstationConfigsRequest {
    /// Required. Parent resource name.
    pub parent: std::string::String,

    /// Optional. Maximum number of items to return.
    pub page_size: i32,

    /// Optional. next_page_token value returned from a previous List request, if
    /// any.
    pub page_token: std::string::String,

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

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

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

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

/// Response message for ListUsableWorkstationConfigs.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListUsableWorkstationConfigsResponse {
    /// The requested configs.
    pub workstation_configs: std::vec::Vec<crate::model::WorkstationConfig>,

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

    /// Unreachable resources.
    pub unreachable: std::vec::Vec<std::string::String>,

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

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

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

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

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

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

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

/// Message for creating a CreateWorkstationConfig.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateWorkstationConfigRequest {
    /// Required. Parent resource name.
    pub parent: std::string::String,

    /// Required. ID to use for the workstation configuration.
    pub workstation_config_id: std::string::String,

    /// Required. Workstation configuration to create.
    pub workstation_config: std::option::Option<crate::model::WorkstationConfig>,

    /// Optional. If set, validate the request and preview the result, but do not
    /// actually apply it.
    pub validate_only: bool,

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

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

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

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

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

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

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

/// Request message for UpdateWorkstationConfig.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateWorkstationConfigRequest {
    /// Required. Workstation configuration to update.
    pub workstation_config: std::option::Option<crate::model::WorkstationConfig>,

    /// Required. Mask specifying which fields in the workstation configuration
    /// should be updated.
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Optional. If set, validate the request and preview the result, but do not
    /// actually apply it.
    pub validate_only: bool,

    /// Optional. If set and the workstation configuration is not found, a new
    /// workstation configuration will be created. In this situation,
    /// update_mask is ignored.
    pub allow_missing: bool,

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

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

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

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

    /// Sets the value of [update_mask][crate::model::UpdateWorkstationConfigRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::UpdateWorkstationConfigRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateWorkstationConfigRequest::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::UpdateWorkstationConfigRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::UpdateWorkstationConfigRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateWorkstationConfigRequest::new().set_or_clear_update_mask(Some(FieldMask::default()/* use setters */));
    /// let x = UpdateWorkstationConfigRequest::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 [validate_only][crate::model::UpdateWorkstationConfigRequest::validate_only].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::UpdateWorkstationConfigRequest;
    /// let x = UpdateWorkstationConfigRequest::new().set_validate_only(true);
    /// ```
    pub fn set_validate_only<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.validate_only = v.into();
        self
    }

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

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

/// Message for deleting a workstation configuration.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteWorkstationConfigRequest {
    /// Required. Name of the workstation configuration to delete.
    pub name: std::string::String,

    /// Optional. If set, validate the request and preview the result, but do not
    /// actually apply it.
    pub validate_only: bool,

    /// Optional. If set, the request is rejected if the latest version of the
    /// workstation configuration on the server does not have this ETag.
    pub etag: std::string::String,

    /// Optional. If set, any workstations in the workstation configuration are
    /// also deleted. Otherwise, the request works only if the workstation
    /// configuration has no workstations.
    pub force: bool,

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

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

    /// Sets the value of [name][crate::model::DeleteWorkstationConfigRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::DeleteWorkstationConfigRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let workstation_cluster_id = "workstation_cluster_id";
    /// # let workstation_config_id = "workstation_config_id";
    /// let x = DeleteWorkstationConfigRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/workstationClusters/{workstation_cluster_id}/workstationConfigs/{workstation_config_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 [validate_only][crate::model::DeleteWorkstationConfigRequest::validate_only].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::DeleteWorkstationConfigRequest;
    /// let x = DeleteWorkstationConfigRequest::new().set_validate_only(true);
    /// ```
    pub fn set_validate_only<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.validate_only = v.into();
        self
    }

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

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

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

/// Request message for GetWorkstation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetWorkstationRequest {
    /// Required. Name of the requested resource.
    pub name: std::string::String,

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

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

    /// Sets the value of [name][crate::model::GetWorkstationRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::GetWorkstationRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let workstation_cluster_id = "workstation_cluster_id";
    /// # let workstation_config_id = "workstation_config_id";
    /// # let workstation_id = "workstation_id";
    /// let x = GetWorkstationRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/workstationClusters/{workstation_cluster_id}/workstationConfigs/{workstation_config_id}/workstations/{workstation_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 GetWorkstationRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.workstations.v1.GetWorkstationRequest"
    }
}

/// Request message for ListWorkstations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListWorkstationsRequest {
    /// Required. Parent resource name.
    pub parent: std::string::String,

    /// Optional. Maximum number of items to return.
    pub page_size: i32,

    /// Optional. next_page_token value returned from a previous List request, if
    /// any.
    pub page_token: std::string::String,

    /// Optional. Filter the Workstations to be listed. Possible filters are
    /// described in <https://google.aip.dev/160>.
    pub filter: std::string::String,

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

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

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

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

/// Response message for ListWorkstations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListWorkstationsResponse {
    /// The requested workstations.
    pub workstations: std::vec::Vec<crate::model::Workstation>,

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

    /// Optional. Unreachable resources.
    pub unreachable: std::vec::Vec<std::string::String>,

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

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

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

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

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

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

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

/// Request message for ListUsableWorkstations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListUsableWorkstationsRequest {
    /// Required. Parent resource name.
    pub parent: std::string::String,

    /// Optional. Maximum number of items to return.
    pub page_size: i32,

    /// Optional. next_page_token value returned from a previous List request, if
    /// any.
    pub page_token: std::string::String,

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

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

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

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

/// Response message for ListUsableWorkstations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListUsableWorkstationsResponse {
    /// The requested workstations.
    pub workstations: std::vec::Vec<crate::model::Workstation>,

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

    /// Unreachable resources.
    pub unreachable: std::vec::Vec<std::string::String>,

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

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

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

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

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

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

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

/// Message for creating a CreateWorkstation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateWorkstationRequest {
    /// Required. Parent resource name.
    pub parent: std::string::String,

    /// Required. ID to use for the workstation.
    pub workstation_id: std::string::String,

    /// Required. Workstation to create. If source_workstation is specified, the
    /// user must have `workstations.workstations.use` permission on the source
    /// workstation, and the Cloud Workstations Service Agent for the project where
    /// you are creating the new workstation must have compute.disks.createSnapshot
    /// and compute.snapshots.useReadOnly on the source project.
    pub workstation: std::option::Option<crate::model::Workstation>,

    /// Optional. If set, validate the request and preview the result, but do not
    /// actually apply it.
    pub validate_only: bool,

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

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

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

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

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

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

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

/// Request message for UpdateWorkstation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateWorkstationRequest {
    /// Required. Workstation to update.
    pub workstation: std::option::Option<crate::model::Workstation>,

    /// Required. Mask specifying which fields in the workstation should be
    /// updated.
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Optional. If set, validate the request and preview the result, but do not
    /// actually apply it.
    pub validate_only: bool,

    /// Optional. If set and the workstation is not found, a new workstation is
    /// created. In this situation, update_mask is ignored.
    pub allow_missing: bool,

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

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

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

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

    /// Sets the value of [update_mask][crate::model::UpdateWorkstationRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::UpdateWorkstationRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateWorkstationRequest::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::UpdateWorkstationRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::UpdateWorkstationRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateWorkstationRequest::new().set_or_clear_update_mask(Some(FieldMask::default()/* use setters */));
    /// let x = UpdateWorkstationRequest::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 [validate_only][crate::model::UpdateWorkstationRequest::validate_only].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::UpdateWorkstationRequest;
    /// let x = UpdateWorkstationRequest::new().set_validate_only(true);
    /// ```
    pub fn set_validate_only<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.validate_only = v.into();
        self
    }

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

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

/// Request message for DeleteWorkstation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteWorkstationRequest {
    /// Required. Name of the workstation to delete.
    pub name: std::string::String,

    /// Optional. If set, validate the request and preview the result, but do not
    /// actually apply it.
    pub validate_only: bool,

    /// Optional. If set, the request will be rejected if the latest version of the
    /// workstation on the server does not have this ETag.
    pub etag: std::string::String,

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

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

    /// Sets the value of [name][crate::model::DeleteWorkstationRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::DeleteWorkstationRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let workstation_cluster_id = "workstation_cluster_id";
    /// # let workstation_config_id = "workstation_config_id";
    /// # let workstation_id = "workstation_id";
    /// let x = DeleteWorkstationRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/workstationClusters/{workstation_cluster_id}/workstationConfigs/{workstation_config_id}/workstations/{workstation_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 [validate_only][crate::model::DeleteWorkstationRequest::validate_only].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::DeleteWorkstationRequest;
    /// let x = DeleteWorkstationRequest::new().set_validate_only(true);
    /// ```
    pub fn set_validate_only<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.validate_only = v.into();
        self
    }

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

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

/// Request message for StartWorkstation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StartWorkstationRequest {
    /// Required. Name of the workstation to start.
    pub name: std::string::String,

    /// Optional. If set, validate the request and preview the result, but do not
    /// actually apply it.
    pub validate_only: bool,

    /// Optional. If set, the request will be rejected if the latest version of the
    /// workstation on the server does not have this ETag.
    pub etag: std::string::String,

    /// Optional. If set, the workstation starts using the boost configuration with
    /// the specified ID.
    pub boost_config: std::string::String,

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

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

    /// Sets the value of [name][crate::model::StartWorkstationRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::StartWorkstationRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let workstation_cluster_id = "workstation_cluster_id";
    /// # let workstation_config_id = "workstation_config_id";
    /// # let workstation_id = "workstation_id";
    /// let x = StartWorkstationRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/workstationClusters/{workstation_cluster_id}/workstationConfigs/{workstation_config_id}/workstations/{workstation_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 [validate_only][crate::model::StartWorkstationRequest::validate_only].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::StartWorkstationRequest;
    /// let x = StartWorkstationRequest::new().set_validate_only(true);
    /// ```
    pub fn set_validate_only<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.validate_only = v.into();
        self
    }

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

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

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

/// Request message for StopWorkstation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StopWorkstationRequest {
    /// Required. Name of the workstation to stop.
    pub name: std::string::String,

    /// Optional. If set, validate the request and preview the result, but do not
    /// actually apply it.
    pub validate_only: bool,

    /// Optional. If set, the request will be rejected if the latest version of the
    /// workstation on the server does not have this ETag.
    pub etag: std::string::String,

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

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

    /// Sets the value of [name][crate::model::StopWorkstationRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::StopWorkstationRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let workstation_cluster_id = "workstation_cluster_id";
    /// # let workstation_config_id = "workstation_config_id";
    /// # let workstation_id = "workstation_id";
    /// let x = StopWorkstationRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/workstationClusters/{workstation_cluster_id}/workstationConfigs/{workstation_config_id}/workstations/{workstation_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 [validate_only][crate::model::StopWorkstationRequest::validate_only].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::StopWorkstationRequest;
    /// let x = StopWorkstationRequest::new().set_validate_only(true);
    /// ```
    pub fn set_validate_only<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.validate_only = v.into();
        self
    }

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

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

/// Request message for GenerateAccessToken.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GenerateAccessTokenRequest {
    /// Required. Name of the workstation for which the access token should be
    /// generated.
    pub workstation: std::string::String,

    /// Optional. Port for which the access token should be generated. If
    /// specified, the generated access token grants access only to the
    /// specified port of the workstation. If specified, values must be within the
    /// range [1 - 65535]. If not specified, the generated access token grants
    /// access to all ports of the workstation.
    pub port: i32,

    /// Desired expiration or lifetime of the access token.
    pub expiration: std::option::Option<crate::model::generate_access_token_request::Expiration>,

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

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

    /// Sets the value of [workstation][crate::model::GenerateAccessTokenRequest::workstation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::GenerateAccessTokenRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let workstation_cluster_id = "workstation_cluster_id";
    /// # let workstation_config_id = "workstation_config_id";
    /// # let workstation_id = "workstation_id";
    /// let x = GenerateAccessTokenRequest::new().set_workstation(format!("projects/{project_id}/locations/{location_id}/workstationClusters/{workstation_cluster_id}/workstationConfigs/{workstation_config_id}/workstations/{workstation_id}"));
    /// ```
    pub fn set_workstation<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.workstation = v.into();
        self
    }

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

    /// Sets the value of [expiration][crate::model::GenerateAccessTokenRequest::expiration].
    ///
    /// Note that all the setters affecting `expiration` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::GenerateAccessTokenRequest;
    /// use wkt::Timestamp;
    /// let x = GenerateAccessTokenRequest::new().set_expiration(Some(
    ///     google_cloud_workstations_v1::model::generate_access_token_request::Expiration::ExpireTime(Timestamp::default().into())));
    /// ```
    pub fn set_expiration<
        T: std::convert::Into<
                std::option::Option<crate::model::generate_access_token_request::Expiration>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.expiration = v.into();
        self
    }

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

    /// Sets the value of [expiration][crate::model::GenerateAccessTokenRequest::expiration]
    /// to hold a `ExpireTime`.
    ///
    /// Note that all the setters affecting `expiration` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::GenerateAccessTokenRequest;
    /// use wkt::Timestamp;
    /// let x = GenerateAccessTokenRequest::new().set_expire_time(Timestamp::default()/* use setters */);
    /// assert!(x.expire_time().is_some());
    /// assert!(x.ttl().is_none());
    /// ```
    pub fn set_expire_time<T: std::convert::Into<std::boxed::Box<wkt::Timestamp>>>(
        mut self,
        v: T,
    ) -> Self {
        self.expiration = std::option::Option::Some(
            crate::model::generate_access_token_request::Expiration::ExpireTime(v.into()),
        );
        self
    }

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

    /// Sets the value of [expiration][crate::model::GenerateAccessTokenRequest::expiration]
    /// to hold a `Ttl`.
    ///
    /// Note that all the setters affecting `expiration` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::GenerateAccessTokenRequest;
    /// use wkt::Duration;
    /// let x = GenerateAccessTokenRequest::new().set_ttl(Duration::default()/* use setters */);
    /// assert!(x.ttl().is_some());
    /// assert!(x.expire_time().is_none());
    /// ```
    pub fn set_ttl<T: std::convert::Into<std::boxed::Box<wkt::Duration>>>(mut self, v: T) -> Self {
        self.expiration = std::option::Option::Some(
            crate::model::generate_access_token_request::Expiration::Ttl(v.into()),
        );
        self
    }
}

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

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

    /// Desired expiration or lifetime of the access token.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Expiration {
        /// Desired expiration time of the access token. This value must
        /// be at most 24 hours in the future. If a value is not specified, the
        /// token's expiration time will be set to a default value of 1 hour in the
        /// future.
        ExpireTime(std::boxed::Box<wkt::Timestamp>),
        /// Desired lifetime duration of the access token. This value must
        /// be at most 24 hours. If a value is not specified, the token's lifetime
        /// will be set to a default value of 1 hour.
        Ttl(std::boxed::Box<wkt::Duration>),
    }
}

/// Response message for GenerateAccessToken.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GenerateAccessTokenResponse {
    /// The generated bearer access token. To use this token, include it in an
    /// Authorization header of an HTTP request sent to the associated
    /// workstation's hostname—for example, `Authorization: Bearer
    /// <access_token>`.
    pub access_token: std::string::String,

    /// Time at which the generated token will expire.
    pub expire_time: std::option::Option<wkt::Timestamp>,

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

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

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

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

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

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

/// Metadata for long-running operations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OperationMetadata {
    /// Output only. Time that the operation was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Time that 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. Human-readable status of the operation, if any.
    pub status_message: std::string::String,

    /// Output only. Identifies whether the user has requested cancellation
    /// of the operation.
    pub requested_cancellation: bool,

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

    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_workstations_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_workstations_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_workstations_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_workstations_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_workstations_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_workstations_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 [status_message][crate::model::OperationMetadata::status_message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_status_message("example");
    /// ```
    pub fn set_status_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.status_message = v.into();
        self
    }

    /// Sets the value of [requested_cancellation][crate::model::OperationMetadata::requested_cancellation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workstations_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_workstations_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
    }
}

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