make regen-apis

2026-02-23 15:49:49 +01:00 · 2024-05-16 21:23:40 +02:00
parent 92ad312680
commit ba42c83516
5108 changed files with 1615625 additions and 992044 deletions
--- a/gen/cloudshell1/src/api/schemas.rs
+++ b/gen/cloudshell1/src/api/schemas.rs
@@ -0,0 +1,254 @@
+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 {}
+
+