google-cloud-shell-v1 1.7.0

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

#![allow(rustdoc::redundant_explicit_links)]
#![allow(rustdoc::broken_intra_doc_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gaxi;
extern crate google_cloud_gax;
extern crate google_cloud_longrunning;
extern crate google_cloud_lro;
extern crate 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 Cloud Shell environment, which is defined as the combination of a Docker
/// image specifying what is installed on the environment and a home directory
/// containing the user's data that will remain across sessions. Each user has
/// at least an environment with the ID "default".
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Environment {
    /// Immutable. Full name of this resource, in the format
    /// `users/{owner_email}/environments/{environment_id}`. `{owner_email}` is the
    /// email address of the user to whom this environment belongs, and
    /// `{environment_id}` is the identifier of this environment. For example,
    /// `users/someone@example.com/environments/default`.
    pub name: std::string::String,

    /// Output only. The environment's identifier, unique among the user's
    /// environments.
    pub id: std::string::String,

    /// Required. Immutable. Full path to the Docker image used to run this environment, e.g.
    /// "gcr.io/dev-con/cloud-devshell:latest".
    pub docker_image: std::string::String,

    /// Output only. Current execution state of this environment.
    pub state: crate::model::environment::State,

    /// Output only. Host to which clients can connect to initiate HTTPS or WSS
    /// connections with the environment.
    pub web_host: std::string::String,

    /// Output only. Username that clients should use when initiating SSH sessions
    /// with the environment.
    pub ssh_username: std::string::String,

    /// Output only. Host to which clients can connect to initiate SSH sessions
    /// with the environment.
    pub ssh_host: std::string::String,

    /// Output only. Port to which clients can connect to initiate SSH sessions
    /// with the environment.
    pub ssh_port: i32,

    /// Output only. Public keys associated with the environment. Clients can
    /// connect to this environment via SSH only if they possess a private key
    /// corresponding to at least one of these public keys. Keys can be added to or
    /// removed from the environment using the AddPublicKey and RemovePublicKey
    /// methods.
    pub public_keys: std::vec::Vec<std::string::String>,

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

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

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

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

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

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

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

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

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

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

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

    /// Possible execution states for an environment.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// The environment's states is unknown.
        Unspecified,
        /// The environment is not running and can't be connected to. Starting the
        /// environment will transition it to the PENDING state.
        Suspended,
        /// The environment is being started but is not yet ready to accept
        /// connections.
        Pending,
        /// The environment is running and ready to accept connections. It will
        /// automatically transition back to DISABLED after a period of inactivity or
        /// if another environment is started.
        Running,
        /// The environment is being deleted and can't be connected to.
        Deleting,
        /// 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::Suspended => std::option::Option::Some(1),
                Self::Pending => std::option::Option::Some(2),
                Self::Running => std::option::Option::Some(3),
                Self::Deleting => 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::Suspended => std::option::Option::Some("SUSPENDED"),
                Self::Pending => std::option::Option::Some("PENDING"),
                Self::Running => std::option::Option::Some("RUNNING"),
                Self::Deleting => std::option::Option::Some("DELETING"),
                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::Suspended,
                2 => Self::Pending,
                3 => Self::Running,
                4 => Self::Deleting,
                _ => 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,
                "SUSPENDED" => Self::Suspended,
                "PENDING" => Self::Pending,
                "RUNNING" => Self::Running,
                "DELETING" => Self::Deleting,
                _ => 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::Suspended => serializer.serialize_i32(1),
                Self::Pending => serializer.serialize_i32(2),
                Self::Running => serializer.serialize_i32(3),
                Self::Deleting => 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.shell.v1.Environment.State",
            ))
        }
    }
}

/// Request message for
/// [GetEnvironment][google.cloud.shell.v1.CloudShellService.GetEnvironment].
///
/// [google.cloud.shell.v1.CloudShellService.GetEnvironment]: crate::client::CloudShellService::get_environment
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetEnvironmentRequest {
    /// Required. Name of the requested resource, for example `users/me/environments/default`
    /// or `users/someone@example.com/environments/default`.
    pub name: std::string::String,

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

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

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

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

/// Message included in the metadata field of operations returned from
/// [CreateEnvironment][google.cloud.shell.v1.CloudShellService.CreateEnvironment].
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateEnvironmentMetadata {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// Message included in the metadata field of operations returned from
/// [DeleteEnvironment][google.cloud.shell.v1.CloudShellService.DeleteEnvironment].
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteEnvironmentMetadata {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// Request message for
/// [StartEnvironment][google.cloud.shell.v1.CloudShellService.StartEnvironment].
///
/// [google.cloud.shell.v1.CloudShellService.StartEnvironment]: crate::client::CloudShellService::start_environment
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StartEnvironmentRequest {
    /// Name of the resource that should be started, for example
    /// `users/me/environments/default` or
    /// `users/someone@example.com/environments/default`.
    pub name: std::string::String,

    /// The initial access token passed to the environment. If this is present and
    /// valid, the environment will be pre-authenticated with gcloud so that the
    /// user can run gcloud commands in Cloud Shell without having to log in. This
    /// code can be updated later by calling AuthorizeEnvironment.
    pub access_token: std::string::String,

    /// Public keys that should be added to the environment before it is started.
    pub public_keys: std::vec::Vec<std::string::String>,

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

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

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

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

/// Request message for
/// [AuthorizeEnvironment][google.cloud.shell.v1.CloudShellService.AuthorizeEnvironment].
///
/// [google.cloud.shell.v1.CloudShellService.AuthorizeEnvironment]: crate::client::CloudShellService::authorize_environment
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AuthorizeEnvironmentRequest {
    /// Name of the resource that should receive the credentials, for example
    /// `users/me/environments/default` or
    /// `users/someone@example.com/environments/default`.
    pub name: std::string::String,

    /// The OAuth access token that should be sent to the environment.
    pub access_token: std::string::String,

    /// The OAuth ID token that should be sent to the environment.
    pub id_token: std::string::String,

    /// The time when the credentials expire. If not set, defaults to one hour from
    /// when the server received the request.
    pub expire_time: std::option::Option<wkt::Timestamp>,

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

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

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

    /// Sets the value of [expire_time][crate::model::AuthorizeEnvironmentRequest::expire_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_shell_v1::model::AuthorizeEnvironmentRequest;
    /// use wkt::Timestamp;
    /// let x = AuthorizeEnvironmentRequest::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::AuthorizeEnvironmentRequest::expire_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_shell_v1::model::AuthorizeEnvironmentRequest;
    /// use wkt::Timestamp;
    /// let x = AuthorizeEnvironmentRequest::new().set_or_clear_expire_time(Some(Timestamp::default()/* use setters */));
    /// let x = AuthorizeEnvironmentRequest::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 AuthorizeEnvironmentRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.shell.v1.AuthorizeEnvironmentRequest"
    }
}

/// Response message for
/// [AuthorizeEnvironment][google.cloud.shell.v1.CloudShellService.AuthorizeEnvironment].
///
/// [google.cloud.shell.v1.CloudShellService.AuthorizeEnvironment]: crate::client::CloudShellService::authorize_environment
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AuthorizeEnvironmentResponse {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// Message included in the metadata field of operations returned from
/// [AuthorizeEnvironment][google.cloud.shell.v1.CloudShellService.AuthorizeEnvironment].
///
/// [google.cloud.shell.v1.CloudShellService.AuthorizeEnvironment]: crate::client::CloudShellService::authorize_environment
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AuthorizeEnvironmentMetadata {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// Message included in the metadata field of operations returned from
/// [StartEnvironment][google.cloud.shell.v1.CloudShellService.StartEnvironment].
///
/// [google.cloud.shell.v1.CloudShellService.StartEnvironment]: crate::client::CloudShellService::start_environment
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StartEnvironmentMetadata {
    /// Current state of the environment being started.
    pub state: crate::model::start_environment_metadata::State,

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

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

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

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

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

    /// Possible states an environment might transition between during startup.
    /// These states are not normally actionable by clients, but may be used to
    /// show a progress message to the user. An environment won't necessarily go
    /// through all of these states when starting. More states are likely to be
    /// added in the future.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// The environment's start state is unknown.
        Unspecified,
        /// The environment is in the process of being started, but no additional
        /// details are available.
        Starting,
        /// Startup is waiting for the user's disk to be unarchived. This can happen
        /// when the user returns to Cloud Shell after not having used it for a
        /// while, and suggests that startup will take longer than normal.
        UnarchivingDisk,
        /// Startup is waiting for compute resources to be assigned to the
        /// environment. This should normally happen very quickly, but an environment
        /// might stay in this state for an extended period of time if the system is
        /// experiencing heavy load.
        AwaitingComputeResources,
        /// Startup has completed. If the start operation was successful, the user
        /// should be able to establish an SSH connection to their environment.
        /// Otherwise, the operation will contain details of the failure.
        Finished,
        /// 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::UnarchivingDisk => std::option::Option::Some(2),
                Self::AwaitingComputeResources => std::option::Option::Some(4),
                Self::Finished => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("STATE_UNSPECIFIED"),
                Self::Starting => std::option::Option::Some("STARTING"),
                Self::UnarchivingDisk => std::option::Option::Some("UNARCHIVING_DISK"),
                Self::AwaitingComputeResources => {
                    std::option::Option::Some("AWAITING_COMPUTE_RESOURCES")
                }
                Self::Finished => std::option::Option::Some("FINISHED"),
                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::UnarchivingDisk,
                3 => Self::Finished,
                4 => Self::AwaitingComputeResources,
                _ => 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,
                "STARTING" => Self::Starting,
                "UNARCHIVING_DISK" => Self::UnarchivingDisk,
                "AWAITING_COMPUTE_RESOURCES" => Self::AwaitingComputeResources,
                "FINISHED" => Self::Finished,
                _ => 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::UnarchivingDisk => serializer.serialize_i32(2),
                Self::AwaitingComputeResources => serializer.serialize_i32(4),
                Self::Finished => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// Message included in the response field of operations returned from
/// [StartEnvironment][google.cloud.shell.v1.CloudShellService.StartEnvironment]
/// once the operation is complete.
///
/// [google.cloud.shell.v1.CloudShellService.StartEnvironment]: crate::client::CloudShellService::start_environment
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StartEnvironmentResponse {
    /// Environment that was started.
    pub environment: std::option::Option<crate::model::Environment>,

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

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

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

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

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

/// Request message for
/// [AddPublicKey][google.cloud.shell.v1.CloudShellService.AddPublicKey].
///
/// [google.cloud.shell.v1.CloudShellService.AddPublicKey]: crate::client::CloudShellService::add_public_key
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AddPublicKeyRequest {
    /// Environment this key should be added to, e.g.
    /// `users/me/environments/default`.
    pub environment: std::string::String,

    /// Key that should be added to the environment. Supported formats are
    /// `ssh-dss` (see RFC4253), `ssh-rsa` (see RFC4253), `ecdsa-sha2-nistp256`
    /// (see RFC5656), `ecdsa-sha2-nistp384` (see RFC5656) and
    /// `ecdsa-sha2-nistp521` (see RFC5656). It should be structured as
    /// &lt;format&gt; &lt;content&gt;, where &lt;content&gt; part is encoded with
    /// Base64.
    pub key: std::string::String,

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

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

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

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

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

/// Response message for
/// [AddPublicKey][google.cloud.shell.v1.CloudShellService.AddPublicKey].
///
/// [google.cloud.shell.v1.CloudShellService.AddPublicKey]: crate::client::CloudShellService::add_public_key
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AddPublicKeyResponse {
    /// Key that was added to the environment.
    pub key: std::string::String,

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

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

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

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

/// Message included in the metadata field of operations returned from
/// [AddPublicKey][google.cloud.shell.v1.CloudShellService.AddPublicKey].
///
/// [google.cloud.shell.v1.CloudShellService.AddPublicKey]: crate::client::CloudShellService::add_public_key
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AddPublicKeyMetadata {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// Request message for
/// [RemovePublicKey][google.cloud.shell.v1.CloudShellService.RemovePublicKey].
///
/// [google.cloud.shell.v1.CloudShellService.RemovePublicKey]: crate::client::CloudShellService::remove_public_key
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RemovePublicKeyRequest {
    /// Environment this key should be removed from, e.g.
    /// `users/me/environments/default`.
    pub environment: std::string::String,

    /// Key that should be removed from the environment.
    pub key: std::string::String,

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

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

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

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

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

/// Response message for
/// [RemovePublicKey][google.cloud.shell.v1.CloudShellService.RemovePublicKey].
///
/// [google.cloud.shell.v1.CloudShellService.RemovePublicKey]: crate::client::CloudShellService::remove_public_key
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RemovePublicKeyResponse {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// Message included in the metadata field of operations returned from
/// [RemovePublicKey][google.cloud.shell.v1.CloudShellService.RemovePublicKey].
///
/// [google.cloud.shell.v1.CloudShellService.RemovePublicKey]: crate::client::CloudShellService::remove_public_key
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RemovePublicKeyMetadata {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// Cloud-shell specific information that will be included as details in failure
/// responses.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CloudShellErrorDetails {
    /// Code indicating the specific error the occurred.
    pub code: crate::model::cloud_shell_error_details::CloudShellErrorCode,

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

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

    /// Sets the value of [code][crate::model::CloudShellErrorDetails::code].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_shell_v1::model::CloudShellErrorDetails;
    /// use google_cloud_shell_v1::model::cloud_shell_error_details::CloudShellErrorCode;
    /// let x0 = CloudShellErrorDetails::new().set_code(CloudShellErrorCode::ImageUnavailable);
    /// let x1 = CloudShellErrorDetails::new().set_code(CloudShellErrorCode::CloudShellDisabled);
    /// let x2 = CloudShellErrorDetails::new().set_code(CloudShellErrorCode::TosViolation);
    /// ```
    pub fn set_code<
        T: std::convert::Into<crate::model::cloud_shell_error_details::CloudShellErrorCode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.code = v.into();
        self
    }
}

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

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

    /// Set of possible errors returned from API calls.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum CloudShellErrorCode {
        /// An unknown error occurred.
        Unspecified,
        /// The image used by the Cloud Shell environment either does not exist or
        /// the user does not have access to it.
        ImageUnavailable,
        /// Cloud Shell has been disabled by an administrator for the user making the
        /// request.
        CloudShellDisabled,
        /// Cloud Shell has been permanently disabled due to a Terms of Service
        /// violation by the user.
        TosViolation,
        /// The user has exhausted their weekly Cloud Shell quota, and Cloud Shell
        /// will be disabled until the quota resets.
        QuotaExceeded,
        /// The Cloud Shell environment is unavailable and cannot be connected to at
        /// the moment.
        EnvironmentUnavailable,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [CloudShellErrorCode::value] or
        /// [CloudShellErrorCode::name].
        UnknownValue(cloud_shell_error_code::UnknownValue),
    }

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

    impl CloudShellErrorCode {
        /// 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::ImageUnavailable => std::option::Option::Some(1),
                Self::CloudShellDisabled => std::option::Option::Some(2),
                Self::TosViolation => std::option::Option::Some(4),
                Self::QuotaExceeded => std::option::Option::Some(5),
                Self::EnvironmentUnavailable => std::option::Option::Some(6),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => {
                    std::option::Option::Some("CLOUD_SHELL_ERROR_CODE_UNSPECIFIED")
                }
                Self::ImageUnavailable => std::option::Option::Some("IMAGE_UNAVAILABLE"),
                Self::CloudShellDisabled => std::option::Option::Some("CLOUD_SHELL_DISABLED"),
                Self::TosViolation => std::option::Option::Some("TOS_VIOLATION"),
                Self::QuotaExceeded => std::option::Option::Some("QUOTA_EXCEEDED"),
                Self::EnvironmentUnavailable => {
                    std::option::Option::Some("ENVIRONMENT_UNAVAILABLE")
                }
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

    impl std::fmt::Display for CloudShellErrorCode {
        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 CloudShellErrorCode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::ImageUnavailable,
                2 => Self::CloudShellDisabled,
                4 => Self::TosViolation,
                5 => Self::QuotaExceeded,
                6 => Self::EnvironmentUnavailable,
                _ => Self::UnknownValue(cloud_shell_error_code::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for CloudShellErrorCode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "CLOUD_SHELL_ERROR_CODE_UNSPECIFIED" => Self::Unspecified,
                "IMAGE_UNAVAILABLE" => Self::ImageUnavailable,
                "CLOUD_SHELL_DISABLED" => Self::CloudShellDisabled,
                "TOS_VIOLATION" => Self::TosViolation,
                "QUOTA_EXCEEDED" => Self::QuotaExceeded,
                "ENVIRONMENT_UNAVAILABLE" => Self::EnvironmentUnavailable,
                _ => Self::UnknownValue(cloud_shell_error_code::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for CloudShellErrorCode {
        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::ImageUnavailable => serializer.serialize_i32(1),
                Self::CloudShellDisabled => serializer.serialize_i32(2),
                Self::TosViolation => serializer.serialize_i32(4),
                Self::QuotaExceeded => serializer.serialize_i32(5),
                Self::EnvironmentUnavailable => serializer.serialize_i32(6),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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