mirror of
https://github.com/OMGeeky/google-apis-rs.git
synced 2026-02-23 15:49:49 +01:00
255 lines
12 KiB
Rust
255 lines
12 KiB
Rust
use super::*;
|
||
/// Request message for AddPublicKey.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [environments add public key users](UserEnvironmentAddPublicKeyCall) (request)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct AddPublicKeyRequest {
|
||
/// 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 <format> <content>, where <content> part is encoded with Base64.
|
||
|
||
pub key: Option<String>,
|
||
}
|
||
|
||
impl client::RequestValue for AddPublicKeyRequest {}
|
||
|
||
|
||
/// Request message for AuthorizeEnvironment.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [environments authorize users](UserEnvironmentAuthorizeCall) (request)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct AuthorizeEnvironmentRequest {
|
||
/// The OAuth access token that should be sent to the environment.
|
||
#[serde(rename="accessToken")]
|
||
|
||
pub access_token: Option<String>,
|
||
/// The time when the credentials expire. If not set, defaults to one hour from when the server received the request.
|
||
#[serde(rename="expireTime")]
|
||
|
||
pub expire_time: Option<client::chrono::DateTime<client::chrono::offset::Utc>>,
|
||
/// The OAuth ID token that should be sent to the environment.
|
||
#[serde(rename="idToken")]
|
||
|
||
pub id_token: Option<String>,
|
||
}
|
||
|
||
impl client::RequestValue for AuthorizeEnvironmentRequest {}
|
||
|
||
|
||
/// The request message for Operations.CancelOperation.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [cancel operations](OperationCancelCall) (request)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct CancelOperationRequest { _never_set: Option<bool> }
|
||
|
||
impl client::RequestValue for CancelOperationRequest {}
|
||
|
||
|
||
/// A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [cancel operations](OperationCancelCall) (response)
|
||
/// * [delete operations](OperationDeleteCall) (response)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Empty { _never_set: Option<bool> }
|
||
|
||
impl client::ResponseResult for Empty {}
|
||
|
||
|
||
/// 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”.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [environments get users](UserEnvironmentGetCall) (response)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Environment {
|
||
/// Required. Immutable. Full path to the Docker image used to run this environment, e.g. "gcr.io/dev-con/cloud-devshell:latest".
|
||
#[serde(rename="dockerImage")]
|
||
|
||
pub docker_image: Option<String>,
|
||
/// Output only. The environment's identifier, unique among the user's environments.
|
||
|
||
pub id: Option<String>,
|
||
/// 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: Option<String>,
|
||
/// 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.
|
||
#[serde(rename="publicKeys")]
|
||
|
||
pub public_keys: Option<Vec<String>>,
|
||
/// Output only. Host to which clients can connect to initiate SSH sessions with the environment.
|
||
#[serde(rename="sshHost")]
|
||
|
||
pub ssh_host: Option<String>,
|
||
/// Output only. Port to which clients can connect to initiate SSH sessions with the environment.
|
||
#[serde(rename="sshPort")]
|
||
|
||
pub ssh_port: Option<i32>,
|
||
/// Output only. Username that clients should use when initiating SSH sessions with the environment.
|
||
#[serde(rename="sshUsername")]
|
||
|
||
pub ssh_username: Option<String>,
|
||
/// Output only. Current execution state of this environment.
|
||
|
||
pub state: Option<EnvironmentStateEnum>,
|
||
/// Output only. Host to which clients can connect to initiate HTTPS or WSS connections with the environment.
|
||
#[serde(rename="webHost")]
|
||
|
||
pub web_host: Option<String>,
|
||
}
|
||
|
||
impl client::ResponseResult for Environment {}
|
||
|
||
|
||
/// The response message for Operations.ListOperations.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [list operations](OperationListCall) (response)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct ListOperationsResponse {
|
||
/// The standard List next-page token.
|
||
#[serde(rename="nextPageToken")]
|
||
|
||
pub next_page_token: Option<String>,
|
||
/// A list of operations that matches the specified filter in the request.
|
||
|
||
pub operations: Option<Vec<Operation>>,
|
||
}
|
||
|
||
impl client::ResponseResult for ListOperationsResponse {}
|
||
|
||
|
||
/// This resource represents a long-running operation that is the result of a network API call.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [cancel operations](OperationCancelCall) (none)
|
||
/// * [delete operations](OperationDeleteCall) (none)
|
||
/// * [get operations](OperationGetCall) (response)
|
||
/// * [list operations](OperationListCall) (none)
|
||
/// * [environments add public key users](UserEnvironmentAddPublicKeyCall) (response)
|
||
/// * [environments authorize users](UserEnvironmentAuthorizeCall) (response)
|
||
/// * [environments remove public key users](UserEnvironmentRemovePublicKeyCall) (response)
|
||
/// * [environments start users](UserEnvironmentStartCall) (response)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Operation {
|
||
/// If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.
|
||
|
||
pub done: Option<bool>,
|
||
/// The error result of the operation in case of failure or cancellation.
|
||
|
||
pub error: Option<Status>,
|
||
/// Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.
|
||
|
||
pub metadata: Option<HashMap<String, json::Value>>,
|
||
/// The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.
|
||
|
||
pub name: Option<String>,
|
||
/// The normal, successful response of the operation. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
|
||
|
||
pub response: Option<HashMap<String, json::Value>>,
|
||
}
|
||
|
||
impl client::Resource for Operation {}
|
||
impl client::ResponseResult for Operation {}
|
||
|
||
|
||
/// Request message for RemovePublicKey.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [environments remove public key users](UserEnvironmentRemovePublicKeyCall) (request)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct RemovePublicKeyRequest {
|
||
/// Key that should be removed from the environment.
|
||
|
||
pub key: Option<String>,
|
||
}
|
||
|
||
impl client::RequestValue for RemovePublicKeyRequest {}
|
||
|
||
|
||
/// Request message for StartEnvironment.
|
||
///
|
||
/// # Activities
|
||
///
|
||
/// This type is used in activities, which are methods you may call on this type or where this type is involved in.
|
||
/// The list links the activity name, along with information about where it is used (one of *request* and *response*).
|
||
///
|
||
/// * [environments start users](UserEnvironmentStartCall) (request)
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct StartEnvironmentRequest {
|
||
/// 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.
|
||
#[serde(rename="accessToken")]
|
||
|
||
pub access_token: Option<String>,
|
||
/// Public keys that should be added to the environment before it is started.
|
||
#[serde(rename="publicKeys")]
|
||
|
||
pub public_keys: Option<Vec<String>>,
|
||
}
|
||
|
||
impl client::RequestValue for StartEnvironmentRequest {}
|
||
|
||
|
||
/// The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).
|
||
///
|
||
/// This type is not used in any activity, and only used as *part* of another schema.
|
||
///
|
||
#[serde_with::serde_as(crate = "::client::serde_with")]
|
||
#[derive(Default, Clone, Debug, Serialize, Deserialize)]
|
||
pub struct Status {
|
||
/// The status code, which should be an enum value of google.rpc.Code.
|
||
|
||
pub code: Option<i32>,
|
||
/// A list of messages that carry the error details. There is a common set of message types for APIs to use.
|
||
|
||
pub details: Option<Vec<HashMap<String, json::Value>>>,
|
||
/// A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
|
||
|
||
pub message: Option<String>,
|
||
}
|
||
|
||
impl client::Part for Status {}
|
||
|
||
|