gcloud-sdk 0.30.0

// This file is @generated by prost-build.
/// A collection of virtual machines and connected resources forming a
/// high-performance computing cluster capable of running large-scale, tightly
/// coupled workloads. A cluster combines a set a compute resources that perform
/// computations, storage resources that contain inputs and store outputs, an
/// orchestrator that is responsible for assigning jobs to compute resources, and
/// network resources that connect everything together.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Cluster {
    /// Identifier. [Relative resource name](<https://google.aip.dev/122>) of the
    /// cluster, in the format
    /// `projects/{project}/locations/{location}/clusters/{cluster}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. User-provided description of the cluster. Maximum of 2048
    /// characters.
    #[prost(string, tag = "9")]
    pub description: ::prost::alloc::string::String,
    /// Optional.
    /// [Labels](<https://cloud.google.com/compute/docs/labeling-resources>) applied
    /// to the cluster. Labels can be used to organize clusters and to filter them
    /// in queries.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Output only. Time that the cluster was originally created.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Time that the cluster was most recently updated.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Indicates whether changes to the cluster are currently in
    /// flight. If this is `true`, then the current state might not match the
    /// cluster's intended state.
    #[prost(bool, tag = "10")]
    pub reconciling: bool,
    /// Optional. Network resources available to the cluster. Must contain exactly
    /// one value. Keys specify the ID of the network resource by which it can be
    /// referenced elsewhere, and must conform to
    /// [RFC-1034](<https://datatracker.ietf.org/doc/html/rfc1034>) (lower-case,
    /// alphanumeric, and at most 63 characters).
    #[prost(map = "string, message", tag = "11")]
    pub network_resources: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        NetworkResource,
    >,
    /// Optional. Storage resources available to the cluster. Keys specify the ID
    /// of the storage resource by which it can be referenced elsewhere, and must
    /// conform to [RFC-1034](<https://datatracker.ietf.org/doc/html/rfc1034>)
    /// (lower-case, alphanumeric, and at most 63 characters).
    #[prost(map = "string, message", tag = "12")]
    pub storage_resources: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        StorageResource,
    >,
    /// Optional. Compute resources available to the cluster. Keys specify the ID
    /// of the compute resource by which it can be referenced elsewhere, and must
    /// conform to [RFC-1034](<https://datatracker.ietf.org/doc/html/rfc1034>)
    /// (lower-case, alphanumeric, and at most 63 characters).
    #[prost(map = "string, message", tag = "13")]
    pub compute_resources: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ComputeResource,
    >,
    /// Optional. Orchestrator that is responsible for scheduling and running jobs
    /// on the cluster.
    #[prost(message, optional, tag = "8")]
    pub orchestrator: ::core::option::Option<Orchestrator>,
    /// Optional. Policy controlling how system-initiated maintenance should be
    /// conducted on the cluster.
    #[prost(message, optional, tag = "14")]
    pub maintenance_policy: ::core::option::Option<MaintenancePolicy>,
    /// Optional. Deprecated. Use compute_resources instead.
    #[deprecated]
    #[prost(message, optional, tag = "7")]
    pub compute: ::core::option::Option<Compute>,
}
/// Request message for
/// \[ListClusters\]\[google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster.ListClusters\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListClustersRequest {
    /// Required. Parent location of the clusters to list, in the format
    /// `projects/{project}/locations/{location}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Maximum number of clusters to return. The service may return
    /// fewer than this value.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A page token received from a previous `ListClusters` call.
    /// Provide this to retrieve the subsequent page. When paginating, all other
    /// parameters provided to `ListClusters` must match the call that provided the
    /// page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. [Filter](<https://google.aip.dev/160>) to apply to the returned
    /// results.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. How to order the resulting clusters. Must be one of the following
    /// strings:
    ///
    /// * `name`
    /// * `name desc`
    /// * `create_time`
    /// * `create_time desc`
    ///
    /// If not specified, clusters will be returned in an arbitrary order.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[ListClusters\]\[google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster.ListClusters\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClustersResponse {
    /// Clusters in the specified location.
    #[prost(message, repeated, tag = "1")]
    pub clusters: ::prost::alloc::vec::Vec<Cluster>,
    /// A token that can be sent as `page_token` to retrieve the next page. If this
    /// field is absent, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Locations that could not be reached.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request message for
/// \[GetCluster\]\[google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster.GetCluster\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetClusterRequest {
    /// Required. Name of the cluster to retrieve, in the format
    /// `projects/{project}/locations/{location}/clusters/{cluster}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[CreateCluster\]\[google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster.CreateCluster\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateClusterRequest {
    /// Required. Parent location in which the cluster should be created, in the
    /// format `projects/{project}/locations/{location}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. ID of the cluster to create. Must conform to
    /// [RFC-1034](<https://datatracker.ietf.org/doc/html/rfc1034>) (lower-case,
    /// alphanumeric, and at most 63 characters).
    #[prost(string, tag = "2")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Required. Cluster to create.
    #[prost(message, optional, tag = "3")]
    pub cluster: ::core::option::Option<Cluster>,
    /// Optional. A unique identifier for this request. A random UUID is
    /// recommended. This request is idempotent if and only if `request_id` is
    /// provided.
    #[prost(string, tag = "4")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for
/// \[UpdateCluster\]\[google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster.UpdateCluster\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateClusterRequest {
    /// Required. Cluster to update.
    #[prost(message, optional, tag = "2")]
    pub cluster: ::core::option::Option<Cluster>,
    /// Optional. Mask specifying which fields in the cluster to update. All paths
    /// must be specified explicitly - wildcards are not supported. At least one
    /// path must be provided.
    #[prost(message, optional, tag = "1")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Optional. A unique identifier for this request. A random UUID is
    /// recommended. This request is idempotent if and only if `request_id` is
    /// provided.
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for
/// \[DeleteCluster\]\[google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster.DeleteCluster\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteClusterRequest {
    /// Required. Name of the cluster to delete, in the format
    /// `projects/{project}/locations/{location}/clusters/{cluster}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. A unique identifier for this request. A random UUID is
    /// recommended. This request is idempotent if and only if `request_id` is
    /// provided.
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// Request message for
/// \[GetNode\]\[google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster.GetNode\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetNodeRequest {
    /// Required. Name of the node to retrieve, in the format
    /// `projects/{project}/locations/{location}/clusters/{cluster}/nodes/{node}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for
/// \[ListNodes\]\[google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster.ListNodes\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListNodesRequest {
    /// Required. Parent cluster of the nodes to list, in the format
    /// `projects/{project}/locations/{location}/clusters/{cluster}`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Maximum number of nodes to return. The service may return fewer
    /// than this value.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A page token received from a previous `ListNodes` call. Provide
    /// this to retrieve the subsequent page. When paginating, all other parameters
    /// provided to `ListNodes` must match the call that provided the page
    /// token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. [Filter](<https://google.aip.dev/160>) to apply to the returned
    /// results.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. How to order the resulting nodes. Must be one of the following
    /// strings:
    ///
    /// * `name`
    /// * `name desc`
    ///
    /// If not specified, nodes will be returned in an arbitrary order.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for
/// \[ListNodes\]\[google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster.ListNodes\].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListNodesResponse {
    /// Nodes in the specified cluster.
    #[prost(message, repeated, tag = "1")]
    pub nodes: ::prost::alloc::vec::Vec<Node>,
    /// A token that can be sent as `page_token` to retrieve the next page. If this
    /// field is absent, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// A resource representing a network that connects the various components of a
/// cluster together.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NetworkResource {
    /// Immutable. Configuration for this network resource, which describes how it
    /// should be created or imported. This field only controls how the network
    /// resource is initially created or imported. Subsequent changes to the
    /// network resource should be made via the resource's API and will not be
    /// reflected in the configuration.
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<NetworkResourceConfig>,
    /// Reference to the network resource in Google Cloud. Exactly one of these
    /// fields will be populated based on the configured type of network resource.
    #[prost(oneof = "network_resource::Reference", tags = "3")]
    pub reference: ::core::option::Option<network_resource::Reference>,
}
/// Nested message and enum types in `NetworkResource`.
pub mod network_resource {
    /// Reference to the network resource in Google Cloud. Exactly one of these
    /// fields will be populated based on the configured type of network resource.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Reference {
        /// Output only. Reference to a network in Google Compute Engine.
        #[prost(message, tag = "3")]
        Network(super::NetworkReference),
    }
}
/// A reference to a [VPC network](<https://cloud.google.com/vpc/docs/vpc>) in
/// Google Compute Engine.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NetworkReference {
    /// Output only. Name of the network, in the format
    /// `projects/{project}/global/networks/{network}`.
    #[prost(string, tag = "1")]
    pub network: ::prost::alloc::string::String,
    /// Output only. Name of the particular subnetwork being used by the cluster,
    /// in the format
    /// `projects/{project}/regions/{region}/subnetworks/{subnetwork}`.
    #[prost(string, tag = "2")]
    pub subnetwork: ::prost::alloc::string::String,
}
/// Describes how a network resource should be initialized. Each network resource
/// can either be imported from an existing Google Cloud resource or initialized
/// when the cluster is created.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NetworkResourceConfig {
    /// Particular type of configuration for this network resource.
    #[prost(oneof = "network_resource_config::Config", tags = "3, 4")]
    pub config: ::core::option::Option<network_resource_config::Config>,
}
/// Nested message and enum types in `NetworkResourceConfig`.
pub mod network_resource_config {
    /// Particular type of configuration for this network resource.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Config {
        /// Optional. Immutable. If set, indicates that a new network should be
        /// created.
        #[prost(message, tag = "3")]
        NewNetwork(super::NewNetworkConfig),
        /// Optional. Immutable. If set, indicates that an existing network should be
        /// imported.
        #[prost(message, tag = "4")]
        ExistingNetwork(super::ExistingNetworkConfig),
    }
}
/// When set in a
/// \[NetworkResourceConfig\]\[google.cloud.hypercomputecluster.v1alpha.NetworkResourceConfig\],
/// indicates that a new network should be created.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NewNetworkConfig {
    /// Required. Immutable. Name of the network to create, in the format
    /// `projects/{project}/global/networks/{network}`.
    #[prost(string, tag = "1")]
    pub network: ::prost::alloc::string::String,
    /// Optional. Immutable. Description of the network. Maximum of 2048
    /// characters.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
}
/// When set in a
/// \[NetworkResourceConfig\]\[google.cloud.hypercomputecluster.v1alpha.NetworkResourceConfig\],
/// indicates that an existing network should be imported.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExistingNetworkConfig {
    /// Required. Immutable. Name of the network to import, in the format
    /// `projects/{project}/global/networks/{network}`.
    #[prost(string, tag = "1")]
    pub network: ::prost::alloc::string::String,
    /// Required. Immutable. Particular subnetwork to use, in the format
    /// `projects/{project}/regions/{region}/subnetworks/{subnetwork}`.
    #[prost(string, tag = "2")]
    pub subnetwork: ::prost::alloc::string::String,
}
/// A resource representing a form of persistent storage that is accessible to
/// compute resources in the cluster.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StorageResource {
    /// Required. Immutable. Configuration for this storage resource, which
    /// describes how it should be created or imported. This field only controls
    /// how the storage resource is initially created or imported. Subsequent
    /// changes to the storage resource should be made via the resource's API and
    /// will not be reflected in the configuration.
    #[prost(message, optional, tag = "4")]
    pub config: ::core::option::Option<StorageResourceConfig>,
    /// Reference to the storage resource in Google Cloud. Exactly one of these
    /// fields will be populated based on the configured type of storage resource.
    #[prost(oneof = "storage_resource::Reference", tags = "1, 2, 3")]
    pub reference: ::core::option::Option<storage_resource::Reference>,
}
/// Nested message and enum types in `StorageResource`.
pub mod storage_resource {
    /// Reference to the storage resource in Google Cloud. Exactly one of these
    /// fields will be populated based on the configured type of storage resource.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Reference {
        /// Output only. Reference to a Filestore instance. Populated if and only if
        /// the storage resource was configured to use Filestore.
        #[prost(message, tag = "1")]
        Filestore(super::FilestoreReference),
        /// Output only. Reference to a Google Cloud Storage bucket. Populated if and
        /// only if the storage resource was configured to use Google Cloud Storage.
        #[prost(message, tag = "2")]
        Bucket(super::BucketReference),
        /// Output only. Reference to a Managed Lustre instance. Populated if and
        /// only if the storage resource was configured to use Managed Lustre.
        #[prost(message, tag = "3")]
        Lustre(super::LustreReference),
    }
}
/// A reference to a [Filestore](<https://cloud.google.com/filestore>) instance.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FilestoreReference {
    /// Output only. Name of the Filestore instance, in the format
    /// `projects/{project}/locations/{location}/instances/{instance}`
    #[prost(string, tag = "1")]
    pub filestore: ::prost::alloc::string::String,
}
/// A reference to a [Google Cloud Storage](<https://cloud.google.com/storage>)
/// bucket.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BucketReference {
    /// Output only. Name of the bucket.
    #[prost(string, tag = "1")]
    pub bucket: ::prost::alloc::string::String,
}
/// A reference to a [Managed
/// Lustre](<https://cloud.google.com/products/managed-lustre>) instance.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LustreReference {
    /// Output only. Name of the Managed Lustre instance, in the format
    /// `projects/{project}/locations/{location}/instances/{instance}`
    #[prost(string, tag = "1")]
    pub lustre: ::prost::alloc::string::String,
}
/// Describes how a storage resource should be initialized. Each storage resource
/// can either be imported from an existing Google Cloud resource or initialized
/// when the cluster is created.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StorageResourceConfig {
    /// Particular type of configuration for this storage resource.
    #[prost(oneof = "storage_resource_config::Config", tags = "1, 2, 3, 4, 5, 6")]
    pub config: ::core::option::Option<storage_resource_config::Config>,
}
/// Nested message and enum types in `StorageResourceConfig`.
pub mod storage_resource_config {
    /// Particular type of configuration for this storage resource.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Config {
        /// Optional. Immutable. If set, indicates that a new Filestore instance
        /// should be created.
        #[prost(message, tag = "1")]
        NewFilestore(super::NewFilestoreConfig),
        /// Optional. Immutable. If set, indicates that an existing Filestore
        /// instance should be imported.
        #[prost(message, tag = "2")]
        ExistingFilestore(super::ExistingFilestoreConfig),
        /// Optional. Immutable. If set, indicates that a new Cloud Storage bucket
        /// should be created.
        #[prost(message, tag = "3")]
        NewBucket(super::NewBucketConfig),
        /// Optional. Immutable. If set, indicates that an existing Cloud Storage
        /// bucket should be imported.
        #[prost(message, tag = "4")]
        ExistingBucket(super::ExistingBucketConfig),
        /// Optional. Immutable. If set, indicates that a new Managed Lustre instance
        /// should be created.
        #[prost(message, tag = "5")]
        NewLustre(super::NewLustreConfig),
        /// Optional. Immutable. If set, indicates that an existing Managed Lustre
        /// instance should be imported.
        #[prost(message, tag = "6")]
        ExistingLustre(super::ExistingLustreConfig),
    }
}
/// When set in a
/// \[StorageResourceConfig\]\[google.cloud.hypercomputecluster.v1alpha.StorageResourceConfig\],
/// indicates that a new [Filestore](<https://cloud.google.com/filestore>) instance
/// should be created.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NewFilestoreConfig {
    /// Required. Immutable. Name of the Filestore instance to create, in the
    /// format `projects/{project}/locations/{location}/instances/{instance}`
    #[prost(string, tag = "1")]
    pub filestore: ::prost::alloc::string::String,
    /// Optional. Immutable. Description of the instance. Maximum of 2048
    /// characters.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Required. Immutable. File system shares on the instance. Exactly one file
    /// share must be specified.
    #[prost(message, repeated, tag = "2")]
    pub file_shares: ::prost::alloc::vec::Vec<FileShareConfig>,
    /// Required. Immutable. Service tier to use for the instance.
    #[prost(enumeration = "new_filestore_config::Tier", tag = "3")]
    pub tier: i32,
    /// Optional. Immutable. Access protocol to use for all file shares in the
    /// instance. Defaults to NFS V3 if not set.
    #[prost(enumeration = "new_filestore_config::Protocol", tag = "5")]
    pub protocol: i32,
}
/// Nested message and enum types in `NewFilestoreConfig`.
pub mod new_filestore_config {
    /// Available [service
    /// tiers](<https://cloud.google.com/filestore/docs/service-tiers>) for Filestore
    /// instances.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Tier {
        /// Not set.
        Unspecified = 0,
        /// Offers expanded capacity and performance scaling capabilities suitable
        /// for high-performance computing application requirements.
        Zonal = 4,
        /// Offers features and availability needed for mission-critical,
        /// high-performance computing workloads.
        Regional = 6,
    }
    impl Tier {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "TIER_UNSPECIFIED",
                Self::Zonal => "ZONAL",
                Self::Regional => "REGIONAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TIER_UNSPECIFIED" => Some(Self::Unspecified),
                "ZONAL" => Some(Self::Zonal),
                "REGIONAL" => Some(Self::Regional),
                _ => None,
            }
        }
    }
    /// File access protocol for Filestore instances.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Protocol {
        /// Not set.
        Unspecified = 0,
        /// NFS 3.0.
        Nfsv3 = 1,
        /// NFS 4.1.
        Nfsv41 = 2,
    }
    impl Protocol {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "PROTOCOL_UNSPECIFIED",
                Self::Nfsv3 => "NFSV3",
                Self::Nfsv41 => "NFSV41",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PROTOCOL_UNSPECIFIED" => Some(Self::Unspecified),
                "NFSV3" => Some(Self::Nfsv3),
                "NFSV41" => Some(Self::Nfsv41),
                _ => None,
            }
        }
    }
}
/// Message describing filestore configuration
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FileShareConfig {
    /// Required. Size of the filestore in GB. Must be between 1024 and 102400, and
    /// must meet scalability requirements described at
    /// <https://cloud.google.com/filestore/docs/service-tiers.>
    #[prost(int64, tag = "1")]
    pub capacity_gb: i64,
    /// Required. Filestore share location
    #[prost(string, tag = "2")]
    pub file_share: ::prost::alloc::string::String,
}
/// When set in a
/// \[StorageResourceConfig\]\[google.cloud.hypercomputecluster.v1alpha.StorageResourceConfig\],
/// indicates that an existing [Filestore](<https://cloud.google.com/filestore>)
/// instance should be imported.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExistingFilestoreConfig {
    /// Required. Immutable. Name of the Filestore instance to import, in the
    /// format `projects/{project}/locations/{location}/instances/{instance}`
    #[prost(string, tag = "1")]
    pub filestore: ::prost::alloc::string::String,
}
/// When set in a
/// \[StorageResourceConfig\]\[google.cloud.hypercomputecluster.v1alpha.StorageResourceConfig\],
/// indicates that a new [Google Cloud Storage](<https://cloud.google.com/storage>)
/// bucket should be created.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NewBucketConfig {
    /// Required. Immutable. Name of the Cloud Storage bucket to create.
    #[prost(string, tag = "1")]
    pub bucket: ::prost::alloc::string::String,
    /// Optional. Immutable. If set, indicates that the bucket should use
    /// [hierarchical
    /// namespaces](<https://cloud.google.com/storage/docs/hns-overview>).
    #[prost(message, optional, tag = "4")]
    pub hierarchical_namespace: ::core::option::Option<GcsHierarchicalNamespaceConfig>,
    /// Storage class of the bucket, which can be set automatically or explicitly.
    #[prost(oneof = "new_bucket_config::Option", tags = "2, 3")]
    pub option: ::core::option::Option<new_bucket_config::Option>,
}
/// Nested message and enum types in `NewBucketConfig`.
pub mod new_bucket_config {
    /// [Storage class](<https://cloud.google.com/storage/docs/storage-classes>) for
    /// a Cloud Storage bucket.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum StorageClass {
        /// Not set.
        Unspecified = 0,
        /// Best for data that is frequently accessed.
        Standard = 1,
        /// Low-cost storage for data that is accessed less frequently.
        Nearline = 2,
        /// Very low-cost storage for infrequently accessed data.
        Coldline = 3,
        /// Lowest-cost storage for data archiving, online backup, and disaster
        /// recovery.
        Archive = 4,
    }
    impl StorageClass {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STORAGE_CLASS_UNSPECIFIED",
                Self::Standard => "STANDARD",
                Self::Nearline => "NEARLINE",
                Self::Coldline => "COLDLINE",
                Self::Archive => "ARCHIVE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STORAGE_CLASS_UNSPECIFIED" => Some(Self::Unspecified),
                "STANDARD" => Some(Self::Standard),
                "NEARLINE" => Some(Self::Nearline),
                "COLDLINE" => Some(Self::Coldline),
                "ARCHIVE" => Some(Self::Archive),
                _ => None,
            }
        }
    }
    /// Storage class of the bucket, which can be set automatically or explicitly.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Option {
        /// Optional. Immutable. If set, indicates that the bucket should use
        /// [Autoclass](<https://cloud.google.com/storage/docs/autoclass>).
        #[prost(message, tag = "2")]
        Autoclass(super::GcsAutoclassConfig),
        /// Optional. Immutable. If set, uses the provided storage class as the
        /// bucket's default storage class.
        #[prost(enumeration = "StorageClass", tag = "3")]
        StorageClass(i32),
    }
}
/// Message describing Google Cloud Storage autoclass configuration
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GcsAutoclassConfig {
    /// Required. Enables Auto-class feature.
    #[prost(bool, tag = "1")]
    pub enabled: bool,
    /// Optional. Terminal storage class of the autoclass bucket
    #[prost(enumeration = "gcs_autoclass_config::TerminalStorageClass", tag = "2")]
    pub terminal_storage_class: i32,
}
/// Nested message and enum types in `GcsAutoclassConfig`.
pub mod gcs_autoclass_config {
    /// Terminal storage class types of the autoclass bucket
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum TerminalStorageClass {
        /// Unspecified terminal storage class
        Unspecified = 0,
        /// Nearline terminal storage class
        Nearline = 1,
        /// Archive terminal storage class
        Archive = 2,
    }
    impl TerminalStorageClass {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "TERMINAL_STORAGE_CLASS_UNSPECIFIED",
                Self::Nearline => "TERMINAL_STORAGE_CLASS_NEARLINE",
                Self::Archive => "TERMINAL_STORAGE_CLASS_ARCHIVE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TERMINAL_STORAGE_CLASS_UNSPECIFIED" => Some(Self::Unspecified),
                "TERMINAL_STORAGE_CLASS_NEARLINE" => Some(Self::Nearline),
                "TERMINAL_STORAGE_CLASS_ARCHIVE" => Some(Self::Archive),
                _ => None,
            }
        }
    }
}
/// Message describing Google Cloud Storage hierarchical namespace configuration
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GcsHierarchicalNamespaceConfig {
    /// Required. Enables hierarchical namespace setup for the bucket.
    #[prost(bool, tag = "1")]
    pub enabled: bool,
}
/// When set in a
/// \[StorageResourceConfig\]\[google.cloud.hypercomputecluster.v1alpha.StorageResourceConfig\],
/// indicates that an existing [Google Cloud
/// Storage](<https://cloud.google.com/storage>) bucket should be imported.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExistingBucketConfig {
    /// Required. Immutable. Name of the Cloud Storage bucket to import.
    #[prost(string, tag = "1")]
    pub bucket: ::prost::alloc::string::String,
}
/// When set in a
/// \[StorageResourceConfig\]\[google.cloud.hypercomputecluster.v1alpha.StorageResourceConfig\],
/// indicates that a new [Managed
/// Lustre](<https://cloud.google.com/products/managed-lustre>) instance should be
/// created.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NewLustreConfig {
    /// Required. Immutable. Name of the Managed Lustre instance to create, in the
    /// format `projects/{project}/locations/{location}/instances/{instance}`
    #[prost(string, tag = "1")]
    pub lustre: ::prost::alloc::string::String,
    /// Optional. Immutable. Description of the Managed Lustre instance. Maximum of
    /// 2048 characters.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Required. Immutable. Filesystem name for this instance. This name is used
    /// by client-side tools, including when mounting the instance. Must be 8
    /// characters or less and can only contain letters and numbers.
    #[prost(string, tag = "3")]
    pub filesystem: ::prost::alloc::string::String,
    /// Required. Immutable. Storage capacity of the instance in gibibytes (GiB).
    /// Allowed values are between 18000 and 7632000.
    #[prost(int64, tag = "4")]
    pub capacity_gb: i64,
    /// Optional. Immutable. Throughput of the instance in MB/s/TiB. Valid values
    /// are 125, 250, 500, 1000. See [Performance tiers and maximum storage
    /// capacities](<https://cloud.google.com/managed-lustre/docs/create-instance#performance-tiers>)
    /// for more information.
    #[prost(int64, tag = "5")]
    pub per_unit_storage_throughput: i64,
}
/// When set in a
/// \[StorageResourceConfig\]\[google.cloud.hypercomputecluster.v1alpha.StorageResourceConfig\],
/// indicates that an existing [Managed
/// Lustre](<https://cloud.google.com/products/managed-lustre>) instance should be
/// imported.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExistingLustreConfig {
    /// Required. Immutable. Name of the Managed Lustre instance to import, in the
    /// format `projects/{project}/locations/{location}/instances/{instance}`
    #[prost(string, tag = "1")]
    pub lustre: ::prost::alloc::string::String,
}
/// A resource defining how virtual machines and accelerators should be
/// provisioned for the cluster.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ComputeResource {
    /// Required. Immutable. Configuration for this compute resource, which
    /// describes how it should be created at runtime.
    #[prost(message, optional, tag = "6")]
    pub config: ::core::option::Option<ComputeResourceConfig>,
}
/// Describes how a compute resource should be created at runtime.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ComputeResourceConfig {
    /// Particular type of configuration for this compute resource.
    #[prost(oneof = "compute_resource_config::Config", tags = "1, 2, 3, 5")]
    pub config: ::core::option::Option<compute_resource_config::Config>,
}
/// Nested message and enum types in `ComputeResourceConfig`.
pub mod compute_resource_config {
    /// Particular type of configuration for this compute resource.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Config {
        /// Optional. Immutable. If set, indicates that this resource should use
        /// on-demand VMs.
        #[prost(message, tag = "1")]
        NewOnDemandInstances(super::NewOnDemandInstancesConfig),
        /// Optional. Immutable. If set, indicates that this resource should use spot
        /// VMs.
        #[prost(message, tag = "2")]
        NewSpotInstances(super::NewSpotInstancesConfig),
        /// Optional. Immutable. If set, indicates that this resource should use
        /// reserved VMs.
        #[prost(message, tag = "3")]
        NewReservedInstances(super::NewReservedInstancesConfig),
        /// Optional. Immutable. If set, indicates that this resource should use
        /// flex-start VMs.
        #[prost(message, tag = "5")]
        NewFlexStartInstances(super::NewFlexStartInstancesConfig),
    }
}
/// When set in a
/// \[ComputeResourceConfig\]\[google.cloud.hypercomputecluster.v1alpha.ComputeResourceConfig\],
/// indicates that on-demand (i.e., using the standard provisioning model) VM
/// instances should be created.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NewOnDemandInstancesConfig {
    /// Required. Immutable. Name of the zone in which VM instances should run,
    /// e.g., `us-central1-a`. Must be in the same region as the cluster, and must
    /// match the zone of any other resources specified in the cluster.
    #[prost(string, tag = "1")]
    pub zone: ::prost::alloc::string::String,
    /// Required. Immutable. Name of the Compute Engine [machine
    /// type](<https://cloud.google.com/compute/docs/machine-resource>) to use, e.g.
    /// `n2-standard-2`.
    #[prost(string, tag = "2")]
    pub machine_type: ::prost::alloc::string::String,
    /// Optional. Immutable. Unstable: Contact hypercompute-service-eng@ before
    /// using.
    #[prost(map = "string, string", tag = "3")]
    pub atm_tags: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// When set in a
/// \[ComputeResourceConfig\]\[google.cloud.hypercomputecluster.v1alpha.ComputeResourceConfig\],
/// indicates that [spot
/// VM](<https://cloud.google.com/compute/docs/instances/spot>) instances should be
/// created.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NewSpotInstancesConfig {
    /// Required. Immutable. Name of the zone in which VM instances should run,
    /// e.g., `us-central1-a`. Must be in the same region as the cluster, and must
    /// match the zone of any other resources specified in the cluster.
    #[prost(string, tag = "1")]
    pub zone: ::prost::alloc::string::String,
    /// Required. Immutable. Name of the Compute Engine [machine
    /// type](<https://cloud.google.com/compute/docs/machine-resource>) to use, e.g.
    /// `n2-standard-2`.
    #[prost(string, tag = "2")]
    pub machine_type: ::prost::alloc::string::String,
    /// Optional. Immutable. Unstable: Contact hypercompute-service-eng@ before
    /// using.
    #[prost(map = "string, string", tag = "3")]
    pub atm_tags: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Termination action for the instance. If not specified, Compute
    /// Engine sets the termination action to DELETE.
    #[prost(enumeration = "new_spot_instances_config::TerminationAction", tag = "5")]
    pub termination_action: i32,
}
/// Nested message and enum types in `NewSpotInstancesConfig`.
pub mod new_spot_instances_config {
    /// Specifies the termination action of the instance
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum TerminationAction {
        /// Not set.
        Unspecified = 0,
        /// Compute Engine stops the Spot VM on preemption.
        Stop = 1,
        /// Compute Engine deletes the Spot VM on preemption.
        Delete = 2,
    }
    impl TerminationAction {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "TERMINATION_ACTION_UNSPECIFIED",
                Self::Stop => "STOP",
                Self::Delete => "DELETE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TERMINATION_ACTION_UNSPECIFIED" => Some(Self::Unspecified),
                "STOP" => Some(Self::Stop),
                "DELETE" => Some(Self::Delete),
                _ => None,
            }
        }
    }
}
/// When set in a
/// \[ComputeResourceConfig\]\[google.cloud.hypercomputecluster.v1alpha.ComputeResourceConfig\],
/// indicates that VM instances should be created from a
/// [reservation](<https://cloud.google.com/compute/docs/instances/reservations-overview>).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NewReservedInstancesConfig {
    /// Optional. Immutable. Unstable: Contact hypercompute-service-eng@ before
    /// using.
    #[prost(map = "string, string", tag = "2")]
    pub atm_tags: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Immutable. Deprecated: Do not use.
    #[deprecated]
    #[prost(string, tag = "3")]
    pub zone: ::prost::alloc::string::String,
    /// Optional. Immutable. Deprecated: Do not use.
    #[deprecated]
    #[prost(string, tag = "4")]
    pub machine_type: ::prost::alloc::string::String,
    /// Source of the reservation
    #[prost(oneof = "new_reserved_instances_config::Source", tags = "1, 7, 8")]
    pub source: ::core::option::Option<new_reserved_instances_config::Source>,
}
/// Nested message and enum types in `NewReservedInstancesConfig`.
pub mod new_reserved_instances_config {
    /// Source of the reservation
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Source {
        /// Optional. Immutable. Name of the reservation from which VM instances
        /// should be created, in the format
        /// `projects/{project}/zones/{zone}/reservations/{reservation}`.
        #[prost(string, tag = "1")]
        Reservation(::prost::alloc::string::String),
        /// Optional. Immutable. Name of the reservation block from which VM
        /// instances should be created, in the format
        /// `projects/{project}/zones/{zone}/reservations/{reservation}/reservationBlocks/{reservation_block}`.
        #[prost(string, tag = "7")]
        ReservationBlock(::prost::alloc::string::String),
        /// Optional. Immutable. Name of the reservation sub block from which VM
        /// instances should be created, in the format
        /// `projects/{project}/zones/{zone}/reservations/{reservation}/reservationBlocks/{reservation_block}/reservationSubBlocks/{reservation_sub_block}`.
        #[prost(string, tag = "8")]
        ReservationSubBlock(::prost::alloc::string::String),
    }
}
/// When set in a
/// \[ComputeResourceConfig\]\[google.cloud.hypercomputecluster.v1alpha.ComputeResourceConfig\],
/// indicates that VM instances should be created using [Flex
/// Start](<https://cloud.google.com/compute/docs/instances/provisioning-models>).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NewFlexStartInstancesConfig {
    /// Required. Immutable. Name of the zone in which VM instances should run,
    /// e.g., `us-central1-a`. Must be in the same region as the cluster, and must
    /// match the zone of any other resources specified in the cluster.
    #[prost(string, tag = "1")]
    pub zone: ::prost::alloc::string::String,
    /// Required. Immutable. Name of the Compute Engine [machine
    /// type](<https://cloud.google.com/compute/docs/machine-resource>) to use, e.g.
    /// `n2-standard-2`.
    #[prost(string, tag = "2")]
    pub machine_type: ::prost::alloc::string::String,
    /// Required. Immutable. Specifies the time limit for created instances.
    /// Instances will be terminated at the end of this duration.
    #[prost(message, optional, tag = "3")]
    pub max_duration: ::core::option::Option<::prost_types::Duration>,
    /// Optional. Immutable. Unstable: Contact hypercompute-service-eng@ before
    /// using.
    #[prost(map = "string, string", tag = "4")]
    pub atm_tags: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// A [Persistent disk](<https://cloud.google.com/compute/docs/disks>) used as the
/// boot disk for a Compute Engine VM instance.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BootDisk {
    /// Required. Immutable. [Persistent disk
    /// type](<https://cloud.google.com/compute/docs/disks#disk-types>), in the
    /// format `projects/{project}/zones/{zone}/diskTypes/{disk_type}`.
    #[prost(string, tag = "1")]
    pub r#type: ::prost::alloc::string::String,
    /// Required. Immutable. Size of the disk in gigabytes. Must be at least 10GB.
    #[prost(int64, tag = "2")]
    pub size_gb: i64,
    /// Optional. Source image family used to create this disk. Must be a
    /// [supported image
    /// family](<https://docs.cloud.google.com/cluster-director/docs/compute#os-images>)
    /// for the VM instance's machine type. If no family is specified, the system
    /// will select a supported image family based on the machine type. If this
    /// field is cleared, the system will continue to use the current image family.
    #[prost(string, tag = "3")]
    pub image: ::prost::alloc::string::String,
    /// Output only. The specific image family that will be used for new VM
    /// instances using this disk. If
    /// \[image\]\[google.cloud.hypercomputecluster.v1alpha.BootDisk.image\] is
    /// non-empty, this field will be set to the same value as `image`. Otherwise,
    /// this field will be set to a system-selected image.
    #[prost(string, tag = "4")]
    pub effective_image: ::prost::alloc::string::String,
}
/// Unstable: Contact hypercompute-service-eng@ before using.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AtmTag {
    /// Required. Unstable: Contact hypercompute-service-eng@ before using.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// Required. Unstable: Contact hypercompute-service-eng@ before using.
    #[prost(string, tag = "2")]
    pub value: ::prost::alloc::string::String,
}
/// The component responsible for scheduling and running workloads on the
/// cluster as well as providing the user interface for interacting with the
/// cluster at runtime.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Orchestrator {
    /// Particular type of orchestrator to use in this cluster.
    #[prost(oneof = "orchestrator::Option", tags = "1")]
    pub option: ::core::option::Option<orchestrator::Option>,
}
/// Nested message and enum types in `Orchestrator`.
pub mod orchestrator {
    /// Particular type of orchestrator to use in this cluster.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Option {
        /// Optional. If set, indicates that the cluster should use Slurm as the
        /// orchestrator.
        #[prost(message, tag = "1")]
        Slurm(super::SlurmOrchestrator),
    }
}
/// When set in
/// \[Orchestrator\]\[google.cloud.hypercomputecluster.v1alpha.Orchestrator\],
/// indicates that the cluster should use [Slurm](<https://slurm.schedmd.com/>) as
/// the orchestrator.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SlurmOrchestrator {
    /// Required. Configuration for login nodes, which allow users to access the
    /// cluster over SSH.
    #[prost(message, optional, tag = "6")]
    pub login_nodes: ::core::option::Option<SlurmLoginNodes>,
    /// Optional. Compute resource configuration for the Slurm nodesets in your
    /// cluster. If not specified, the cluster won't create any nodes.
    #[prost(message, repeated, tag = "1")]
    pub node_sets: ::prost::alloc::vec::Vec<SlurmNodeSet>,
    /// Optional. Configuration for the Slurm partitions in your cluster. Each
    /// partition can contain one or more nodesets, and you can submit separate
    /// jobs on each partition. If you don't specify at least one partition in your
    /// cluster, you can't submit jobs to the cluster.
    #[prost(message, repeated, tag = "2")]
    pub partitions: ::prost::alloc::vec::Vec<SlurmPartition>,
    /// Optional. Default partition to use for submitted jobs that do not
    /// explicitly specify a partition. Required if and only if there is more than
    /// one partition, in which case it must match the id of one of the partitions.
    #[prost(string, tag = "3")]
    pub default_partition: ::prost::alloc::string::String,
    /// Optional. Slurm [prolog
    /// scripts](<https://slurm.schedmd.com/prolog_epilog.html>), which will be
    /// executed by compute nodes before a node begins running a new job. Values
    /// must not be empty.
    #[prost(string, repeated, tag = "4")]
    pub prolog_bash_scripts: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Slurm [epilog
    /// scripts](<https://slurm.schedmd.com/prolog_epilog.html>), which will be
    /// executed by compute nodes whenever a node finishes running a job. Values
    /// must not be empty.
    #[prost(string, repeated, tag = "5")]
    pub epilog_bash_scripts: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Unstable: Contact hypercompute-service-eng@ before using.
    #[prost(message, optional, tag = "7")]
    pub config: ::core::option::Option<slurm_orchestrator::SlurmConfig>,
    /// Optional. Unstable: Contact hypercompute-service-eng@ before using.
    #[prost(string, repeated, tag = "8")]
    pub task_prolog_bash_scripts: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// Optional. Unstable: Contact hypercompute-service-eng@ before using.
    #[prost(string, repeated, tag = "9")]
    pub task_epilog_bash_scripts: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// Optional. Unstable: Contact hypercompute-service-eng@ before using.
    /// If true, health checking is disabled, and health_check_interval,
    /// health_check_node_state, and health_check_program should not be passed in.
    #[prost(bool, tag = "10")]
    pub disable_health_check_program: bool,
}
/// Nested message and enum types in `SlurmOrchestrator`.
pub mod slurm_orchestrator {
    /// Slurm orchestrator configuration. Values correspond to a subset of those
    /// found in <https://slurm.schedmd.com/slurm.conf.html.>
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct SlurmConfig {
        /// Optional. Enables automatic requeue for batch jobs which exit with the
        /// specified values. Default is empty. Corresponds to RequeueExit.
        #[prost(int64, repeated, packed = "false", tag = "1")]
        pub requeue_exit_codes: ::prost::alloc::vec::Vec<i64>,
        /// Optional. Enables automatic requeue for batch jobs which exit with the
        /// specified values, with these jobs being held until released manually by
        /// the user. Default is empty. Corresponds to RequeueExitHold.
        #[prost(int64, repeated, packed = "false", tag = "2")]
        pub requeue_hold_exit_codes: ::prost::alloc::vec::Vec<i64>,
        /// Optional. Flags to control the Prolog behavior. By default no flags are
        /// set. Corresponds to PrologFlags.
        #[prost(
            enumeration = "slurm_config::PrologFlag",
            repeated,
            packed = "false",
            tag = "3"
        )]
        pub prolog_flags: ::prost::alloc::vec::Vec<i32>,
        /// Optional. The interval Slurm waits for Prolog and Epilog before
        /// terminating them. Default is 65534 seconds. Corresponds to
        /// PrologEpilogTimeout.
        #[prost(message, optional, tag = "4")]
        pub prolog_epilog_timeout: ::core::option::Option<::prost_types::Duration>,
        /// Optional. Flags to control the level of association to impose on job
        /// submissions. By default no flags are set. Corresponds to
        /// AccountingStorageEnforce.
        #[prost(
            enumeration = "slurm_config::AccountingStorageEnforceFlag",
            repeated,
            packed = "false",
            tag = "5"
        )]
        pub accounting_storage_enforce_flags: ::prost::alloc::vec::Vec<i32>,
        /// Optional. Specifies the plugin to be used in establishing a job's
        /// scheduling priority. Set this value to "priority/multifactor" to enable
        /// the Multifactor Job Priority Plugin.
        #[prost(enumeration = "slurm_config::PriorityType", tag = "6")]
        pub priority_type: i32,
        /// Optional. An unsigned integer that scales the contribution of the age
        /// factor.
        #[prost(int64, tag = "7")]
        pub priority_weight_age: i64,
        /// Optional. An unsigned integer that scales the contribution of the
        /// association factor.
        #[prost(int64, tag = "8")]
        pub priority_weight_assoc: i64,
        /// Optional. An unsigned integer that scales the contribution of the
        /// fair-share factor.
        #[prost(int64, tag = "9")]
        pub priority_weight_fairshare: i64,
        /// Optional. An unsigned integer that scales the contribution of the job
        /// size factor.
        #[prost(int64, tag = "10")]
        pub priority_weight_job_size: i64,
        /// Optional. An unsigned integer that scales the contribution of the
        /// partition factor.
        #[prost(int64, tag = "11")]
        pub priority_weight_partition: i64,
        /// Optional. An unsigned integer that scales the contribution of the quality
        /// of service factor.
        #[prost(int64, tag = "12")]
        pub priority_weight_qos: i64,
        /// Optional. A comma-separated list of TRES Types and weights that sets the
        /// degree that each TRES Type contributes to the job's priority.
        #[prost(string, tag = "13")]
        pub priority_weight_tres: ::prost::alloc::string::String,
        /// Optional. Specifies the mechanism used to preempt jobs or enable gang
        /// scheduling.
        #[prost(
            enumeration = "slurm_config::PreemptMode",
            repeated,
            packed = "false",
            tag = "14"
        )]
        pub preempt_mode: ::prost::alloc::vec::Vec<i32>,
        /// Optional. Specifies the plugin used to identify which jobs can be
        /// preempted in order to start a pending job.
        #[prost(enumeration = "slurm_config::PreemptType", tag = "15")]
        pub preempt_type: i32,
        /// Optional. Specifies minimum run time of jobs before they are considered
        /// for preemption.
        #[prost(string, tag = "16")]
        pub preempt_exempt_time: ::prost::alloc::string::String,
        /// Optional. The interval in seconds between executions of
        /// HealthCheckProgram. If provided, must be > 0. To disable health checks,
        /// use disable_health_check_program instead.
        #[prost(int64, tag = "17")]
        pub health_check_interval: i64,
        /// Optional. The node state to check for. Allowed values are "ALLOC", "ANY",
        /// "CYCLE", "IDLE", "NONDRAINED_IDLE", "MIXED", and "START_ONLY". Multiple
        /// state values may be specified with a comma separator.
        #[prost(string, tag = "18")]
        pub health_check_node_state: ::prost::alloc::string::String,
        /// Optional. The fully-qualified path to the health check program to be
        /// executed.
        #[prost(string, tag = "19")]
        pub health_check_program: ::prost::alloc::string::String,
    }
    /// Nested message and enum types in `SlurmConfig`.
    pub mod slurm_config {
        /// Flags to control the Prolog behavior.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum PrologFlag {
            /// Unspecified prolog flag.
            Unspecified = 0,
            /// Prolog script will be executed at job allocation. NOTE: increases the
            /// time required to start jobs. Corresponds to Alloc.
            Alloc = 1,
            /// Use the ProcTrack plugin to create a job container on all allocated
            /// compute nodes. Corresponds to Contain.
            Contain = 2,
            /// Slurmctld will wait until the prolog completes on all allocated nodes
            /// before sending the batch job launch request. Corresponds to DeferBatch.
            DeferBatch = 3,
            /// If set, the ALLOC flag should also be set. This will allow for salloc
            /// to not block until the prolog is finished on each node. Corresponds to
            /// NoHold.
            NoHold = 4,
            /// Always requeue it automatically even if the job requested no requeues.
            /// NOTE: Setting this flag implicitly sets the ALLOC flag. Corresponds to
            /// ForceRequeueOnFail.
            ForceRequeueOnFail = 5,
            /// Make the Prolog/Epilog run in the extern slurmstepd. Corresponds to
            /// RunInJob.
            RunInJob = 6,
            /// Force prolog and epilog scripts to run serially within each node. NOTE:
            /// This is incompatible with Serial.
            Serial = 7,
            /// Enable Slurm's built-in X11 forwarding capabilities. Corresponds to
            /// X11.
            X11 = 8,
        }
        impl PrologFlag {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Unspecified => "PROLOG_FLAG_UNSPECIFIED",
                    Self::Alloc => "ALLOC",
                    Self::Contain => "CONTAIN",
                    Self::DeferBatch => "DEFER_BATCH",
                    Self::NoHold => "NO_HOLD",
                    Self::ForceRequeueOnFail => "FORCE_REQUEUE_ON_FAIL",
                    Self::RunInJob => "RUN_IN_JOB",
                    Self::Serial => "SERIAL",
                    Self::X11 => "X11",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "PROLOG_FLAG_UNSPECIFIED" => Some(Self::Unspecified),
                    "ALLOC" => Some(Self::Alloc),
                    "CONTAIN" => Some(Self::Contain),
                    "DEFER_BATCH" => Some(Self::DeferBatch),
                    "NO_HOLD" => Some(Self::NoHold),
                    "FORCE_REQUEUE_ON_FAIL" => Some(Self::ForceRequeueOnFail),
                    "RUN_IN_JOB" => Some(Self::RunInJob),
                    "SERIAL" => Some(Self::Serial),
                    "X11" => Some(Self::X11),
                    _ => None,
                }
            }
        }
        /// Flags to control the level of association to impose on job submissions.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum AccountingStorageEnforceFlag {
            /// Unspecified accounting storage enforce flag.
            Unspecified = 0,
            /// Implies all other available options except nojobs and nosteps.
            All = 1,
            /// No new job will be allowed to run unless a corresponding association
            /// exists in the system.
            Associations = 2,
            /// Users will be limited by association to whatever job size or run time
            /// limits are defined. Implies associations.
            Limits = 3,
            /// Slurm will not account for any jobs or steps on the system. Implies
            /// nosteps.
            Nojobs = 4,
            /// Slurm will not account for any steps that have run.
            Nosteps = 5,
            /// Jobs will not be scheduled unless a valid qos is specified. Implies
            /// associations.
            Qos = 6,
            /// A job will only be launched against an association or qos that has a
            /// TRES-minutes limit set if the job will be able to run to completion.
            /// Without this option set, jobs will be launched as long as their usage
            /// hasn't reached the TRES-minutes limit. This can lead to jobs being
            /// launched but then killed when the limit is reached. With this option, a
            /// job won't be killed due to limits, even if the limits are changed after
            /// the job was started and the association or qos violates the updated
            /// limits. Implies limits and associations.
            Safe = 7,
            /// Jobs will not be scheduled unless a valid workload characterization key
            /// is specified. Implies associations and TrackWCKey (a separate
            /// configuration option).
            Wckeys = 8,
        }
        impl AccountingStorageEnforceFlag {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Unspecified => "ACCOUNTING_STORAGE_ENFORCE_FLAG_UNSPECIFIED",
                    Self::All => "ALL",
                    Self::Associations => "ASSOCIATIONS",
                    Self::Limits => "LIMITS",
                    Self::Nojobs => "NOJOBS",
                    Self::Nosteps => "NOSTEPS",
                    Self::Qos => "QOS",
                    Self::Safe => "SAFE",
                    Self::Wckeys => "WCKEYS",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "ACCOUNTING_STORAGE_ENFORCE_FLAG_UNSPECIFIED" => {
                        Some(Self::Unspecified)
                    }
                    "ALL" => Some(Self::All),
                    "ASSOCIATIONS" => Some(Self::Associations),
                    "LIMITS" => Some(Self::Limits),
                    "NOJOBS" => Some(Self::Nojobs),
                    "NOSTEPS" => Some(Self::Nosteps),
                    "QOS" => Some(Self::Qos),
                    "SAFE" => Some(Self::Safe),
                    "WCKEYS" => Some(Self::Wckeys),
                    _ => None,
                }
            }
        }
        /// Specifies the plugin to be used in establishing a job's scheduling
        /// priority.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum PriorityType {
            /// Unspecified priority type.
            Unspecified = 0,
            /// Jobs are evaluated in a First In, First Out (FIFO) manner.
            PriorityBasic = 1,
            /// Jobs are assigned a priority based upon a variety of factors that
            /// include size, age, Fairshare, etc.
            PriorityMultifactor = 2,
        }
        impl PriorityType {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Unspecified => "PRIORITY_TYPE_UNSPECIFIED",
                    Self::PriorityBasic => "PRIORITY_BASIC",
                    Self::PriorityMultifactor => "PRIORITY_MULTIFACTOR",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "PRIORITY_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "PRIORITY_BASIC" => Some(Self::PriorityBasic),
                    "PRIORITY_MULTIFACTOR" => Some(Self::PriorityMultifactor),
                    _ => None,
                }
            }
        }
        /// Specifies the mechanism used to preempt jobs or enable gang scheduling.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum PreemptMode {
            /// Unspecified preempt mode.
            Unspecified = 0,
            /// Is the default value and disables job preemption and gang scheduling.
            Off = 1,
            /// The preempted job will be cancelled
            Cancel = 2,
            /// Enables gang scheduling (time slicing) of jobs in the same partition,
            /// and allows the resuming of suspended jobs.
            Gang = 3,
            /// Preempts jobs by requeuing them (if possible) or canceling them.
            Requeue = 4,
            /// The preempted jobs will be suspended, and later the Gang scheduler will
            /// resume them.
            Suspend = 5,
            /// Allow preemption only if the preemptor's job priority is higher than
            /// the preemptee's job priority.
            Priority = 6,
            /// Allow jobs within the same qos to preempt one another.
            Within = 7,
        }
        impl PreemptMode {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Unspecified => "PREEMPT_MODE_UNSPECIFIED",
                    Self::Off => "OFF",
                    Self::Cancel => "CANCEL",
                    Self::Gang => "GANG",
                    Self::Requeue => "REQUEUE",
                    Self::Suspend => "SUSPEND",
                    Self::Priority => "PRIORITY",
                    Self::Within => "WITHIN",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "PREEMPT_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                    "OFF" => Some(Self::Off),
                    "CANCEL" => Some(Self::Cancel),
                    "GANG" => Some(Self::Gang),
                    "REQUEUE" => Some(Self::Requeue),
                    "SUSPEND" => Some(Self::Suspend),
                    "PRIORITY" => Some(Self::Priority),
                    "WITHIN" => Some(Self::Within),
                    _ => None,
                }
            }
        }
        /// Specifies the plugin used to identify which jobs can be preempted in
        /// order to start a pending job.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum PreemptType {
            /// Unspecified preempt type.
            Unspecified = 0,
            /// Job preemption is disabled (default).
            PreemptNone = 1,
            /// Job preemption is based upon partition PriorityTier.
            PreemptPartitionPrio = 2,
            /// Job preemption rules are specified by Quality Of Service (QOS)
            /// specifications in the Slurm database.
            PreemptQos = 3,
        }
        impl PreemptType {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Unspecified => "PREEMPT_TYPE_UNSPECIFIED",
                    Self::PreemptNone => "PREEMPT_NONE",
                    Self::PreemptPartitionPrio => "PREEMPT_PARTITION_PRIO",
                    Self::PreemptQos => "PREEMPT_QOS",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "PREEMPT_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "PREEMPT_NONE" => Some(Self::PreemptNone),
                    "PREEMPT_PARTITION_PRIO" => Some(Self::PreemptPartitionPrio),
                    "PREEMPT_QOS" => Some(Self::PreemptQos),
                    _ => None,
                }
            }
        }
    }
}
/// Configuration for Slurm nodesets in the cluster. Nodesets are groups of
/// compute nodes used by Slurm that are responsible for running workloads
/// submitted to the cluster.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SlurmNodeSet {
    /// Required. Identifier for the nodeset, which allows it to be referenced by
    /// partitions. Must conform to
    /// [RFC-1034](<https://datatracker.ietf.org/doc/html/rfc1034>) (lower-case,
    /// alphanumeric, and at most 63 characters).
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Required. ID of the compute resource on which this nodeset will run. Must
    /// match a key in the cluster's
    /// \[compute_resources\]\[google.cloud.hypercomputecluster.v1alpha.Cluster.compute_resources\].
    #[prost(string, tag = "16")]
    pub compute_id: ::prost::alloc::string::String,
    /// Optional. How \[storage
    /// resources\]\[google.cloud.hypercomputecluster.v1alpha.StorageResource\] should
    /// be mounted on each compute node.
    #[prost(message, repeated, tag = "3")]
    pub storage_configs: ::prost::alloc::vec::Vec<StorageConfig>,
    /// Optional. Number of nodes to be statically created for this nodeset. The
    /// cluster will attempt to ensure that at least this many nodes exist at all
    /// times.
    #[prost(int64, tag = "4")]
    pub static_node_count: i64,
    /// Optional. Controls how many additional nodes a cluster can bring online to
    /// handle workloads. Set this value to enable dynamic node creation and limit
    /// the number of additional nodes the cluster can bring online. Leave empty if
    /// you do not want the cluster to create nodes dynamically, and instead rely
    /// only on static nodes.
    #[prost(int64, tag = "5")]
    pub max_dynamic_node_count: i64,
    /// Optional. Unstable: Contact hypercompute-service-eng@ before using.
    #[prost(message, optional, tag = "13")]
    pub service_account: ::core::option::Option<ServiceAccount>,
    /// Optional. Whether compute node instances should be assigned [external IP
    /// addresses](<https://cloud.google.com/compute/docs/ip-addresses#externaladdresses>).
    #[prost(bool, tag = "11")]
    pub enable_public_ips: bool,
    /// Optional. Deprecated: Use
    /// \[ComputeInstanceSlurmNodeSet.startup_script\]\[google.cloud.hypercomputecluster.v1alpha.ComputeInstanceSlurmNodeSet.startup_script\]
    /// instead.
    #[deprecated]
    #[prost(string, tag = "7")]
    pub startup_script: ::prost::alloc::string::String,
    /// Optional. Deprecated: Do not use.
    #[deprecated]
    #[prost(bool, tag = "9")]
    pub enable_os_login: bool,
    /// Optional. Deprecated: Use
    /// \[ComputeInstanceSlurmNodeSet.labels\]\[google.cloud.hypercomputecluster.v1alpha.ComputeInstanceSlurmNodeSet.labels\]
    /// instead.
    #[prost(map = "string, string", tag = "12")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Additional configuration for the nodeset. If not set, the nodeset will
    /// use
    /// \[ComputeInstanceSlurmNodeSet\]\[google.cloud.hypercomputecluster.v1alpha.ComputeInstanceSlurmNodeSet\]
    /// with default values.
    #[prost(oneof = "slurm_node_set::Type", tags = "17, 18")]
    pub r#type: ::core::option::Option<slurm_node_set::Type>,
}
/// Nested message and enum types in `SlurmNodeSet`.
pub mod slurm_node_set {
    /// Additional configuration for the nodeset. If not set, the nodeset will
    /// use
    /// \[ComputeInstanceSlurmNodeSet\]\[google.cloud.hypercomputecluster.v1alpha.ComputeInstanceSlurmNodeSet\]
    /// with default values.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Type {
        /// Optional. If set, indicates that the nodeset should be backed by Compute
        /// Engine instances.
        #[prost(message, tag = "17")]
        ComputeInstance(super::ComputeInstanceSlurmNodeSet),
        /// Optional. If set, indicates that the nodeset should be backed by a
        /// Kubernetes Engine node pool.
        #[prost(message, tag = "18")]
        ContainerNodePool(super::ContainerNodePoolSlurmNodeSet),
    }
}
/// When set in a
/// \[SlurmNodeSet\]\[google.cloud.hypercomputecluster.v1alpha.SlurmNodeSet\],
/// indicates that the nodeset should be backed by Compute Engine VM instances.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ComputeInstanceSlurmNodeSet {
    /// Optional. [Startup
    /// script](<https://cloud.google.com/compute/docs/instances/startup-scripts/linux>)
    /// to be run on each VM instance in the nodeset. Max 256KB.
    #[prost(string, tag = "1")]
    pub startup_script: ::prost::alloc::string::String,
    /// Optional.
    /// [Labels](<https://cloud.google.com/compute/docs/labeling-resources>) that
    /// should be applied to each VM instance in the nodeset.
    #[prost(map = "string, string", tag = "2")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Boot disk for the compute instance
    #[prost(message, optional, tag = "3")]
    pub boot_disk: ::core::option::Option<BootDisk>,
    /// Optional. The maximum time to wait for the startup script to complete. If
    /// the script exceeds this duration, the instance setup will be considered
    /// failed. This value must be positive. If this value is unset, a default
    /// timeout of 5 minutes (300 seconds) will be used by the system.
    #[prost(message, optional, tag = "4")]
    pub startup_script_timeout: ::core::option::Option<::prost_types::Duration>,
}
/// When set in a
/// \[SlurmNodeSet\]\[google.cloud.hypercomputecluster.v1alpha.SlurmNodeSet\],
/// indicates that the nodeset should be backed by a Kubernetes Engine node pool.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContainerNodePoolSlurmNodeSet {
    /// Optional. Resource labels that are applied to the underlying Google Compute
    /// Engine resources.
    #[prost(map = "string, string", tag = "1")]
    pub resource_labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Script to run in each pod in the nodeset when it first starts.
    /// Max 256KB.
    #[prost(string, tag = "2")]
    pub startup_script: ::prost::alloc::string::String,
}
/// Configuration for Slurm partitions in the cluster. Partitions are groups of
/// nodesets, and are how clients specify where their workloads should be run.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlurmPartition {
    /// Required. ID of the partition, which is how users will identify it. Must
    /// conform to [RFC-1034](<https://datatracker.ietf.org/doc/html/rfc1034>)
    /// (lower-case, alphanumeric, and at most 63 characters).
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Required. IDs of the nodesets that make up this partition. Values must
    /// match
    /// \[SlurmNodeSet.id\]\[google.cloud.hypercomputecluster.v1alpha.SlurmNodeSet.id\].
    #[prost(string, repeated, tag = "2")]
    pub node_set_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Unstable: Contact hypercompute-service-eng@ before using.
    #[prost(bool, tag = "3")]
    pub exclusive: bool,
}
/// Configuration for Slurm [login
/// nodes](<https://slurm.schedmd.com/quickstart_admin.html#login>) in the cluster.
/// Login nodes are Compute Engine VM instances that allow users to access the
/// cluster over SSH.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SlurmLoginNodes {
    /// Required. Number of login node instances to create.
    #[prost(int64, tag = "3")]
    pub count: i64,
    /// Required. Name of the zone in which login nodes should run, e.g.,
    /// `us-central1-a`. Must be in the same region as the cluster, and must match
    /// the zone of any other resources specified in the cluster.
    #[prost(string, tag = "2")]
    pub zone: ::prost::alloc::string::String,
    /// Required. Name of the Compute Engine [machine
    /// type](<https://cloud.google.com/compute/docs/machine-resource>) to use for
    /// login nodes, e.g. `n2-standard-2`.
    #[prost(string, tag = "1")]
    pub machine_type: ::prost::alloc::string::String,
    /// Optional. [Startup
    /// script](<https://cloud.google.com/compute/docs/instances/startup-scripts/linux>)
    /// to be run on each login node instance. Max 256KB.
    /// The script must complete within the system-defined default timeout of 5
    /// minutes. For tasks that require more time, consider running them in the
    /// background using methods such as `&` or `nohup`.
    #[prost(string, tag = "5")]
    pub startup_script: ::prost::alloc::string::String,
    /// Optional. Whether [OS Login](<https://cloud.google.com/compute/docs/oslogin>)
    /// should be enabled on login node instances.
    #[prost(bool, tag = "6")]
    pub enable_os_login: bool,
    /// Optional. Whether login node instances should be assigned [external IP
    /// addresses](<https://cloud.google.com/compute/docs/ip-addresses#externaladdresses>).
    #[prost(bool, tag = "7")]
    pub enable_public_ips: bool,
    /// Optional.
    /// [Labels](<https://cloud.google.com/compute/docs/labeling-resources>) that
    /// should be applied to each login node instance.
    #[prost(map = "string, string", tag = "8")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. How \[storage
    /// resources\]\[google.cloud.hypercomputecluster.v1alpha.StorageResource\] should
    /// be mounted on each login node.
    #[prost(message, repeated, tag = "12")]
    pub storage_configs: ::prost::alloc::vec::Vec<StorageConfig>,
    /// Output only. Information about the login node instances that were created
    /// in Compute Engine.
    #[prost(message, repeated, tag = "10")]
    pub instances: ::prost::alloc::vec::Vec<ComputeInstance>,
    /// Optional. Boot disk for the login node.
    #[prost(message, optional, tag = "13")]
    pub boot_disk: ::core::option::Option<BootDisk>,
    /// Optional. Unstable: Contact hypercompute-service-eng@ before using.
    #[prost(message, optional, tag = "9")]
    pub service_account: ::core::option::Option<ServiceAccount>,
}
/// Service account email and scopes
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ServiceAccount {
    /// Optional. Service account email
    #[prost(string, tag = "1")]
    pub email: ::prost::alloc::string::String,
    /// Optional. Service account scopes
    #[prost(string, repeated, tag = "2")]
    pub scopes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Description of how a \[storage
/// resource\]\[google.cloud.hypercomputecluster.v1alpha.StorageResource\] should be
/// mounted on a VM instance.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StorageConfig {
    /// Required. ID of the storage resource to mount, which must match a key in
    /// the cluster's
    /// \[storage_resources\]\[google.cloud.hypercomputecluster.v1alpha.Cluster.storage_resources\].
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Required. A directory inside the VM instance's file system where the
    /// storage resource should be mounted (e.g., `/mnt/share`).
    #[prost(string, tag = "2")]
    pub local_mount: ::prost::alloc::string::String,
}
/// Details about a Compute Engine
/// [instance](<https://cloud.google.com/compute/docs/instances>).
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ComputeInstance {
    /// Output only. Name of the VM instance, in the format
    /// `projects/{project}/zones/{zone}/instances/{instance}`.
    #[prost(string, tag = "1")]
    pub instance: ::prost::alloc::string::String,
}
/// Policy controlling how system-initiated maintenance should be conducted on
/// the cluster.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MaintenancePolicy {
    /// Optional. Periods during which the system may perform maintenance
    /// operations on the cluster that might carry a risk of disruption. The system
    /// will make a best-effort attempt to only perform maintenance within these
    /// windows. If no windows are specified, the system may perform maintenance at
    /// any time. All windows must have same start_time and duration.
    #[prost(message, repeated, tag = "1")]
    pub windows: ::prost::alloc::vec::Vec<MaintenanceWindow>,
}
/// A window of time in which maintenance is allowed.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MaintenanceWindow {
    /// Required. Day of the week on which maintenance may be performed.
    #[prost(enumeration = "super::super::super::r#type::DayOfWeek", tag = "1")]
    pub day: i32,
    /// Required. Time in UTC during the given day when the system is allowed to
    /// start performing maintenance.
    #[prost(message, optional, tag = "2")]
    pub start_time: ::core::option::Option<super::super::super::r#type::TimeOfDay>,
    /// Required. Duration of the maintenance window. The system will attempt to
    /// complete maintenance within this duration from start_time. Must be between
    /// 4 and 24 hours.
    #[prost(message, optional, tag = "3")]
    pub duration: ::core::option::Option<::prost_types::Duration>,
}
/// Message describing Compute object
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Compute {
    /// Optional. ATM Tags to attach to compute VM instances
    #[prost(message, repeated, tag = "2")]
    pub atm_tags: ::prost::alloc::vec::Vec<AtmTag>,
}
/// A resource representing a compute node managed by Cluster Director.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Node {
    /// Identifier. [Relative resource name](<https://google.aip.dev/122>) of the
    /// node, in the format
    /// `projects/{project}/locations/{location}/clusters/{cluster}/nodes/{node}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Name of the zone in which the node is running, e.g.
    /// `us-central1-a`.
    #[prost(string, tag = "2")]
    pub zone: ::prost::alloc::string::String,
    /// Output only. High-level lifecycle state of the node.
    #[prost(enumeration = "node::State", tag = "3")]
    pub state: i32,
    /// Output only. Human-readable message providing extra information about the
    /// current state.
    #[prost(string, tag = "4")]
    pub state_message: ::prost::alloc::string::String,
    /// Output only. Indicates whether the node is currently executing workloads.
    #[prost(bool, tag = "5")]
    pub running_jobs: bool,
    /// Output only. Indicates whether the node is available for new job
    /// allocations.
    #[prost(bool, tag = "6")]
    pub accepting_jobs: bool,
    /// Output only. Slurm-specific details for the node.
    #[prost(message, optional, tag = "7")]
    pub slurm_details: ::core::option::Option<SlurmNodeDetails>,
    /// Output only. Compute Engine-specific details for the node.
    #[prost(message, optional, tag = "8")]
    pub compute_engine_details: ::core::option::Option<ComputeEngineNodeDetails>,
    /// Output only. Container Engine-specific details for the node.
    #[prost(message, optional, tag = "9")]
    pub container_engine_details: ::core::option::Option<ContainerEngineNodeDetails>,
    /// Output only. Time that the node was originally created.
    #[prost(message, optional, tag = "10")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Time that the node was most recently updated.
    #[prost(message, optional, tag = "11")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Nested message and enum types in `Node`.
pub mod node {
    /// High-level lifecycle state of the node.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Not set.
        Unspecified = 0,
        /// The node is being provisioned at the infrastructure layer or
        /// initialized by the orchestrator.
        Creating = 1,
        /// The node is healthy and operational.
        Active = 2,
        /// The node is transitioning to a stopped or suspended state.
        Suspending = 3,
        /// The node is suspended or stopped and not consuming compute resources.
        Suspended = 4,
        /// The node is undergoing maintenance or automatic recovery.
        Repairing = 5,
        /// The node is in an unhealthy or terminal error state.
        Failed = 6,
        /// The node is being deleted.
        Deleting = 7,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STATE_UNSPECIFIED",
                Self::Creating => "CREATING",
                Self::Active => "ACTIVE",
                Self::Suspending => "SUSPENDING",
                Self::Suspended => "SUSPENDED",
                Self::Repairing => "REPAIRING",
                Self::Failed => "FAILED",
                Self::Deleting => "DELETING",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "CREATING" => Some(Self::Creating),
                "ACTIVE" => Some(Self::Active),
                "SUSPENDING" => Some(Self::Suspending),
                "SUSPENDED" => Some(Self::Suspended),
                "REPAIRING" => Some(Self::Repairing),
                "FAILED" => Some(Self::Failed),
                "DELETING" => Some(Self::Deleting),
                _ => None,
            }
        }
    }
}
/// Slurm-specific details for a Node.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SlurmNodeDetails {
    /// Output only. Raw state flags directly from Slurm.
    #[prost(string, repeated, tag = "1")]
    pub states: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. User-readable reason for the current state.
    #[prost(string, tag = "2")]
    pub reason: ::prost::alloc::string::String,
    /// Output only. Slurm partitions this node belongs to.
    #[prost(string, repeated, tag = "3")]
    pub partitions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. The ID of the nodeset this node belongs to.
    #[prost(string, tag = "4")]
    pub nodeset: ::prost::alloc::string::String,
    /// Output only. System comments from Slurm.
    #[prost(string, tag = "5")]
    pub comment: ::prost::alloc::string::String,
}
/// Compute Engine-specific details for a Node.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ComputeEngineNodeDetails {
    /// Output only. [Relative resource name](<https://google.aip.dev/122>) of the VM
    /// instance, in the format
    /// `projects/{project}/zones/{zone}/instances/{instance}`.
    #[prost(string, tag = "1")]
    pub instance: ::prost::alloc::string::String,
    /// Output only. Name of the Compute Engine [machine
    /// type](<https://cloud.google.com/compute/docs/machine-resource>) to use, e.g.
    /// `n2-standard-2`.
    #[prost(string, tag = "2")]
    pub machine_type: ::prost::alloc::string::String,
    /// Output only. The Compute Engine VM [instance lifecycle
    /// state](<https://cloud.google.com/compute/docs/instances/instance-lifecycle>).
    #[prost(string, tag = "3")]
    pub state: ::prost::alloc::string::String,
}
/// Container Engine-specific details for a Node.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ContainerEngineNodeDetails {
    /// Output only. [Relative resource name](<https://google.aip.dev/122>) of the
    /// pod, in the format
    /// `projects/{project}/locations/{location}/clusters/{cluster}/k8s/namespaces/{namespace}/pods/{pod}`.
    #[prost(string, tag = "1")]
    pub pod: ::prost::alloc::string::String,
    /// Output only. The Container Engine [pod lifecycle
    /// state](<https://kubernetes.io/docs/Concepts/Workloads/Pods/Pod-lifecycle/>).
    #[prost(string, tag = "2")]
    pub state: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod hypercompute_cluster_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service describing handlers for resources
    #[derive(Debug, Clone)]
    pub struct HypercomputeClusterClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl HypercomputeClusterClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> HypercomputeClusterClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> HypercomputeClusterClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            HypercomputeClusterClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Lists Clusters in a given project and location.
        pub async fn list_clusters(
            &mut self,
            request: impl tonic::IntoRequest<super::ListClustersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListClustersResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster/ListClusters",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster",
                        "ListClusters",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of a single Cluster.
        pub async fn get_cluster(
            &mut self,
            request: impl tonic::IntoRequest<super::GetClusterRequest>,
        ) -> std::result::Result<tonic::Response<super::Cluster>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster/GetCluster",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster",
                        "GetCluster",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new Cluster in a given project and location.
        pub async fn create_cluster(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster/CreateCluster",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster",
                        "CreateCluster",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the parameters of a single Cluster.
        pub async fn update_cluster(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster/UpdateCluster",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster",
                        "UpdateCluster",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a single Cluster.
        pub async fn delete_cluster(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster/DeleteCluster",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster",
                        "DeleteCluster",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of a single Node.
        pub async fn get_node(
            &mut self,
            request: impl tonic::IntoRequest<super::GetNodeRequest>,
        ) -> std::result::Result<tonic::Response<super::Node>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster/GetNode",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster",
                        "GetNode",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists Nodes in a given cluster.
        pub async fn list_nodes(
            &mut self,
            request: impl tonic::IntoRequest<super::ListNodesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListNodesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster/ListNodes",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.HypercomputeCluster",
                        "ListNodes",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A Machine Learning run.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MachineLearningRun {
    /// Identifier. The name of the Machine Learning run.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Display name for the run.
    #[prost(string, tag = "2")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. Allows grouping of similar runs.
    ///
    /// * Helps improving UI rendering performance.
    /// * Allows comparing similar runs via fast filters.
    #[prost(string, tag = "3")]
    pub run_set: ::prost::alloc::string::String,
    /// Optional. ETag for the run.
    /// It must be provided for update/delete operations and must match the
    /// server's etag.
    #[prost(string, tag = "4")]
    pub etag: ::prost::alloc::string::String,
    /// Optional. Tracks configuration for this run,
    /// example: batch_size, jax_version, tpu_generation etc.
    #[prost(message, optional, tag = "5")]
    pub configs: ::core::option::Option<Configs>,
    /// Required. List of tools enabled for this run
    /// example: XProf, SMon
    #[prost(message, repeated, tag = "6")]
    pub tools: ::prost::alloc::vec::Vec<Tool>,
    /// Optional. Deprecated: Use Cloud Logging to retrieve metrics information.
    /// Metrics for the run.
    #[deprecated]
    #[prost(message, optional, tag = "7")]
    pub metrics: ::core::option::Option<Metrics>,
    /// Optional. Any custom labels for this run
    /// Example: type:workload, type:simulation etc.
    #[prost(map = "string, string", tag = "8")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Output only. State of the run.
    #[prost(enumeration = "State", tag = "9")]
    pub state: i32,
    /// Output only. Time when the run was created.
    #[prost(message, optional, tag = "10")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Time when the run was last updated.
    #[prost(message, optional, tag = "11")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. Artifacts for the run.
    #[prost(message, optional, tag = "12")]
    pub artifacts: ::core::option::Option<Artifacts>,
    /// Required. The orchestrator used for the run.
    #[prost(enumeration = "machine_learning_run::Orchestrator", tag = "13")]
    pub orchestrator: i32,
    /// Optional. The metadata for the workload associated with the run.
    #[prost(message, optional, tag = "14")]
    pub workload_details: ::core::option::Option<WorkloadDetails>,
    /// Optional. RunPhase defines the phase of the run.
    #[prost(enumeration = "machine_learning_run::RunPhase", tag = "15")]
    pub run_phase: i32,
    /// Optional. Error details for the run.
    /// This field is set when the run is failed.
    #[prost(string, tag = "16")]
    pub error_details: ::prost::alloc::string::String,
    /// Output only. Time when the run was completed.
    /// This field is set when the run is completed or failed.
    #[prost(message, optional, tag = "17")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. Allows grouping of similar runs.
    ///
    /// * Helps improving UI rendering performance.
    /// * Allows comparing similar runs via fast filters.
    #[prost(string, tag = "18")]
    pub run_group: ::prost::alloc::string::String,
}
/// Nested message and enum types in `MachineLearningRun`.
pub mod machine_learning_run {
    /// Orchestrator for the ML run like Google Compute Engine, Google
    /// Kubernetes Engine, Slurm etc.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Orchestrator {
        /// Orchestrator type is not specified.
        Unspecified = 0,
        /// Google Compute Engine orchestrator.
        Gce = 1,
        /// Google Kubernetes Engine orchestrator.
        Gke = 2,
        /// Slurm cluster orchestrator.
        Slurm = 3,
    }
    impl Orchestrator {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "ORCHESTRATOR_UNSPECIFIED",
                Self::Gce => "GCE",
                Self::Gke => "GKE",
                Self::Slurm => "SLURM",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ORCHESTRATOR_UNSPECIFIED" => Some(Self::Unspecified),
                "GCE" => Some(Self::Gce),
                "GKE" => Some(Self::Gke),
                "SLURM" => Some(Self::Slurm),
                _ => None,
            }
        }
    }
    /// RunPhase defines the phase of the Machine Learning run.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RunPhase {
        /// State is not specified.
        Unspecified = 0,
        /// Run is active.
        Active = 1,
        /// Run is completed.
        Completed = 2,
        /// Run is failed.
        Failed = 3,
    }
    impl RunPhase {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "RUN_PHASE_UNSPECIFIED",
                Self::Active => "ACTIVE",
                Self::Completed => "COMPLETED",
                Self::Failed => "FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RUN_PHASE_UNSPECIFIED" => Some(Self::Unspecified),
                "ACTIVE" => Some(Self::Active),
                "COMPLETED" => Some(Self::Completed),
                "FAILED" => Some(Self::Failed),
                _ => None,
            }
        }
    }
}
/// A Profiler Target.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProfilerTarget {
    /// Identifier. The resource name of the ProfilerTarget.
    /// Format:
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}/profilerTargets/{profiler_target}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Whether this node is the master node in the cluster.
    #[prost(bool, tag = "2")]
    pub is_master: bool,
    /// Required. Host name of the node / target.
    #[prost(string, tag = "3")]
    pub hostname: ::prost::alloc::string::String,
    /// Required. Index of the node in the cluster.
    #[prost(int32, tag = "4")]
    pub node_index: i32,
    /// Optional. Etag for the profiler target
    #[prost(string, tag = "5")]
    pub etag: ::prost::alloc::string::String,
}
/// Represents a single profiler session.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProfilerSession {
    /// Identifier. The name of the profiler session.
    /// Format:
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}/profilerSessions/{profiler_session}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The cloud storage path of the session. Example:
    /// `gs://my-bucket/my-run-directory/session-1`.
    #[prost(string, tag = "2")]
    pub storage_folder_uri: ::prost::alloc::string::String,
    /// Output only. The creation time of the session.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The URI to dashboard to see session specific data. Not
    /// specified if URI is not ready yet. Form
    /// <https://<backend>?\<params(gsc_bucket|etc>)> Could contain user information
    /// like bucket name etc.
    #[prost(string, tag = "4")]
    pub dashboard_uri: ::prost::alloc::string::String,
    /// Optional. Customer setting to enable trace level details for the session.
    #[prost(bool, tag = "5")]
    pub is_trace_enabled: bool,
    /// Optional. Duration for the profiler session.
    #[prost(message, optional, tag = "6")]
    pub duration: ::core::option::Option<::prost_types::Duration>,
    /// Optional. Etag for optimistic concurrency control.
    #[prost(string, tag = "7")]
    pub etag: ::prost::alloc::string::String,
    /// Required. List of profiler targets.
    /// Targets on which profiler session to be started.
    #[prost(string, repeated, tag = "8")]
    pub profiler_targets: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Host tracer level for the session. If the field is not set or
    /// unspecified, the default is `HOST_TRACER_LEVEL_INFO`.
    #[prost(enumeration = "profiler_session::HostTracerLevel", tag = "9")]
    pub host_tracer_level: i32,
    /// Optional. Device tracer level for the session. If the field is not set or
    /// unspecified, the default is `DEVICE_TRACER_LEVEL_ENABLED`.
    #[prost(enumeration = "profiler_session::DeviceTracerLevel", tag = "11")]
    pub device_tracer_level: i32,
    /// Optional. Profiler session kind.
    #[prost(enumeration = "profiler_session::Kind", tag = "12")]
    pub kind: i32,
    /// Optional. Python tracer level for the session. If the field is not set or
    /// unspecified, the default is `PYTHON_TRACER_LEVEL_DISABLED`.
    #[prost(enumeration = "profiler_session::PythonTracerLevel", tag = "13")]
    pub python_tracer_level: i32,
}
/// Nested message and enum types in `ProfilerSession`.
pub mod profiler_session {
    /// LINT.IfChange
    /// Host tracer levels. It can have new values in future.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum HostTracerLevel {
        /// Tracer level is unspecified.
        Unspecified = 0,
        /// Tracer level is disabled.
        Disabled = 1,
        /// Tracer level is critical.
        Critical = 2,
        /// Tracer level is info.
        Info = 3,
        /// Tracer level is verbose.
        Verbose = 4,
    }
    impl HostTracerLevel {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "HOST_TRACER_LEVEL_UNSPECIFIED",
                Self::Disabled => "HOST_TRACER_LEVEL_DISABLED",
                Self::Critical => "HOST_TRACER_LEVEL_CRITICAL",
                Self::Info => "HOST_TRACER_LEVEL_INFO",
                Self::Verbose => "HOST_TRACER_LEVEL_VERBOSE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "HOST_TRACER_LEVEL_UNSPECIFIED" => Some(Self::Unspecified),
                "HOST_TRACER_LEVEL_DISABLED" => Some(Self::Disabled),
                "HOST_TRACER_LEVEL_CRITICAL" => Some(Self::Critical),
                "HOST_TRACER_LEVEL_INFO" => Some(Self::Info),
                "HOST_TRACER_LEVEL_VERBOSE" => Some(Self::Verbose),
                _ => None,
            }
        }
    }
    /// LINT.IfChange
    /// Device tracer levels. It can have new values in future.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DeviceTracerLevel {
        /// Tracer level is unspecified.
        Unspecified = 0,
        /// Tracer level is disabled.
        Disabled = 1,
        /// Tracer level is enabled.
        Enabled = 2,
    }
    impl DeviceTracerLevel {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "DEVICE_TRACER_LEVEL_UNSPECIFIED",
                Self::Disabled => "DEVICE_TRACER_LEVEL_DISABLED",
                Self::Enabled => "DEVICE_TRACER_LEVEL_ENABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DEVICE_TRACER_LEVEL_UNSPECIFIED" => Some(Self::Unspecified),
                "DEVICE_TRACER_LEVEL_DISABLED" => Some(Self::Disabled),
                "DEVICE_TRACER_LEVEL_ENABLED" => Some(Self::Enabled),
                _ => None,
            }
        }
    }
    /// Profiler session kind.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Kind {
        /// Profiler session kind is unspecified.
        Unspecified = 0,
        /// Profiler session created via Command Line Interface / UI / API on demand
        /// request.
        OnDemand = 1,
        /// Profiler session created via SDK start() and stop() calls within workload
        /// code.
        Programmatic = 2,
        /// Profiler session is scanned from Google Cloud Storage bucket.
        Scanned = 3,
    }
    impl Kind {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "KIND_UNSPECIFIED",
                Self::OnDemand => "KIND_ON_DEMAND",
                Self::Programmatic => "KIND_PROGRAMMATIC",
                Self::Scanned => "KIND_SCANNED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "KIND_UNSPECIFIED" => Some(Self::Unspecified),
                "KIND_ON_DEMAND" => Some(Self::OnDemand),
                "KIND_PROGRAMMATIC" => Some(Self::Programmatic),
                "KIND_SCANNED" => Some(Self::Scanned),
                _ => None,
            }
        }
    }
    /// LINT.IfChange
    /// Python tracer levels. It can have new values in future.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum PythonTracerLevel {
        /// Tracer level is unspecified.
        Unspecified = 0,
        /// Tracer level is disabled.
        Disabled = 1,
        /// Tracer level is enabled.
        Enabled = 2,
    }
    impl PythonTracerLevel {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "PYTHON_TRACER_LEVEL_UNSPECIFIED",
                Self::Disabled => "PYTHON_TRACER_LEVEL_DISABLED",
                Self::Enabled => "PYTHON_TRACER_LEVEL_ENABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PYTHON_TRACER_LEVEL_UNSPECIFIED" => Some(Self::Unspecified),
                "PYTHON_TRACER_LEVEL_DISABLED" => Some(Self::Disabled),
                "PYTHON_TRACER_LEVEL_ENABLED" => Some(Self::Enabled),
                _ => None,
            }
        }
    }
}
/// Represents a single Monitored Event (Incident) detected by the system.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MonitoredEvent {
    /// Identifier. Resource name of the monitored event.
    /// Format:
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}/monitoredEvents/{monitored_event}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. High-level type of the event.
    #[prost(enumeration = "monitored_event::EventType", tag = "2")]
    pub r#type: i32,
    /// Optional. Display name of the event.
    /// If not provided, this will default to the Monitored Event ID from the
    /// resource name.
    #[prost(string, tag = "9")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. Inclusive timestamp when the event started.
    #[prost(message, optional, tag = "3")]
    pub start_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. Exclusive timestamp when the event ended. If unset, the event is
    /// ongoing.
    #[prost(message, optional, tag = "4")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. Detailed reports from one or more analyzers regarding this event.
    #[prost(message, repeated, tag = "6")]
    pub analyzer_reports: ::prost::alloc::vec::Vec<AnalyzerReport>,
    /// Output only. Identifies if any of the analyzer found an insight for this
    /// event.
    #[prost(bool, tag = "10")]
    pub analyzer_insight_found: bool,
}
/// Nested message and enum types in `MonitoredEvent`.
pub mod monitored_event {
    /// Enum for sorting/filtering events by category.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EventType {
        /// Event type not specified.
        Unspecified = 0,
        /// Performance degradation event.
        PerformanceDegradation = 1,
    }
    impl EventType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "EVENT_TYPE_UNSPECIFIED",
                Self::PerformanceDegradation => "PERFORMANCE_DEGRADATION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "EVENT_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "PERFORMANCE_DEGRADATION" => Some(Self::PerformanceDegradation),
                _ => None,
            }
        }
    }
}
/// Represents a single profiling session.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProfileSession {
    /// Identifier. The name of the profile session.
    /// Format:
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}/profileSessions/{profile_session}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The cloud storage path of the session. Example:
    /// `gs://my-bucket/my-run-directory/session-1`.
    #[prost(string, tag = "2")]
    pub gcs_path: ::prost::alloc::string::String,
    /// Output only. The creation time of the session.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The URL to dashboard to see session specific data. Not
    /// specified if URL is not ready yet. Currently represents only Xprof.
    ///
    /// Form <https://<backend>?\<params(gsc_bucket|etc>)>
    /// Could contains user information like bucket name etc.
    #[prost(string, tag = "4")]
    pub dashboard_url: ::prost::alloc::string::String,
}
/// Request message for MachineLearningRuns.CreateMachineLearningRun.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateMachineLearningRunRequest {
    /// Required. Parent format: projects/{project}/locations/{location}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The Machine Learning Run to create.
    #[prost(message, optional, tag = "2")]
    pub machine_learning_run: ::core::option::Option<MachineLearningRun>,
    /// Optional. The ID of the Machine Learning Run to create.
    #[prost(string, tag = "3")]
    pub machine_learning_run_id: ::prost::alloc::string::String,
}
/// Request message for MachineLearningRuns.GetMachineLearningRun.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetMachineLearningRunRequest {
    /// Required.
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for MachineLearningRuns.ListMachineLearningRuns.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListMachineLearningRunsRequest {
    /// Required. projects/{project}/locations/{location}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of Machine Learning Runs to return. The
    /// service may return fewer than this value. If unspecified, at most 10
    /// Machine Learning Runs will be returned. The maximum value is 1000; values
    /// above 1000 will be coerced to 1000. Please refer to
    /// <https://google.aip.dev/158> for more details.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A page token, received from a previous `ListMachineLearningRuns`
    /// call. Provide this to retrieve the subsequent page. Please refer to
    /// <https://google.aip.dev/158> for more details.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. An expression for filtering the results of the request.
    ///
    /// Supported filter fields are:
    ///
    /// * run_id (string): The ID of the run (e.g., "run-1").
    /// * run_set (string): The run set (e.g., "run-set-1").
    /// * display_name (string): The display name of the run (e.g.,
    ///   "display-name-1").
    /// * state (enum): The state of the run (e.g., "STATE_COMPLETED").
    /// * region (string): The region of the run (e.g., "us-central1").
    /// * orchestrator (enum): The orchestrator used for the run (e.g.,
    ///   "ORCHESTRATOR_GKE").
    /// * create_time (timestamp): The creation timestamp of the run.
    /// * update_time (timestamp): The last update timestamp of the run.
    /// * etag (string): The ETag of the run.
    ///
    /// Filter expressions can be combined using "AND" and "OR" operators.
    ///
    /// Examples:
    ///
    /// To filter by a single field:
    ///
    /// `run_set = "run-set-1"`
    /// `state = "STATE_ACTIVE"`
    ///
    /// To filter by multiple fields:
    ///
    /// `run_set = "run-set-1" AND state = "STATE_ACTIVE"`
    /// `region = "us-central1" AND orchestrator = "ORCHESTRATOR_GKE"`
    ///
    /// To filter by timestamp:
    ///
    /// `create_time > "2025-05-26T10:00:00Z"`
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. A comma-separated list of fields to order by, sorted in ascending
    /// order. Use "desc" after a field name for descending.
    ///
    /// Supported fields:
    ///
    /// * `run_id`
    /// * `run_set`
    /// * `display_name`
    /// * `region`
    /// * `orchestrator`
    /// * `state`
    /// * `create_time`
    /// * `update_time`
    ///
    /// Example: `update_time desc, create_time`.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for MachineLearningRuns.ListMachineLearningRuns.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListMachineLearningRunsResponse {
    /// The Machine Learning Runs.
    #[prost(message, repeated, tag = "1")]
    pub machine_learning_runs: ::prost::alloc::vec::Vec<MachineLearningRun>,
    /// A token, which can be sent as `page_token` to retrieve the next page.
    /// If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for MachineLearningRuns.UpdateMachineLearningRun.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateMachineLearningRunRequest {
    /// Required. The Machine Learning Run to update.
    #[prost(message, optional, tag = "1")]
    pub machine_learning_run: ::core::option::Option<MachineLearningRun>,
    /// Optional. Used to identify fields to be updated. Allowed fields is \*, we
    /// don't support partial updates.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for MachineLearningRuns.DeleteMachineLearningRun.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteMachineLearningRunRequest {
    /// Required.
    /// projects/{project}/locations/{location}/machineLearningRuns/{machineLearningRun}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. If force=false and if a user tries to delete an ml run resource
    /// that still has child resources (e.g., ProfilerTarget), the request should
    /// fail with a FAILED_PRECONDITION error. If force=true, the delete request
    /// should delete both parent and child resources that exist.
    #[prost(bool, tag = "3")]
    pub force: bool,
}
/// Create profiler target request
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateProfilerTargetRequest {
    /// Required.
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The Profiler Target to create.
    #[prost(message, optional, tag = "2")]
    pub profiler_target: ::core::option::Option<ProfilerTarget>,
    /// Optional. If not provided, the server will generate an ID based on hostname
    /// and node_index. Example: "myhost-0"
    #[prost(string, tag = "3")]
    pub profiler_target_id: ::prost::alloc::string::String,
}
/// Get profiler target request
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetProfilerTargetRequest {
    /// Required.
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}/profilerTargets/{profiler_target}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for listing profiler targets.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListProfilerTargetsRequest {
    /// Required.
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of profiler targets to return. The service may
    /// return fewer than this value. If unspecified, at most 10 profiler targets
    /// will be returned. The maximum value is 1000; values above 1000 will be
    /// coerced to 1000. Please refer to <https://google.aip.dev/158> for more
    /// details.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A page token, received from a previous `ListProfilerTargets`
    /// call. Provide this to retrieve the subsequent page. Please refer to
    /// <https://google.aip.dev/158> for more details.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for list profiler targets.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProfilerTargetsResponse {
    /// A list of profiler targets.
    #[prost(message, repeated, tag = "1")]
    pub profiler_targets: ::prost::alloc::vec::Vec<ProfilerTarget>,
    /// A token, which can be sent as `page_token` to retrieve the next page.
    /// If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for Deleting a ProfilerTarget.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteProfilerTargetRequest {
    /// Required. The name of the profiler target to delete.
    /// Format:
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}/profilerTargets/{profiler_target}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for creating a profiler session.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateProfilerSessionRequest {
    /// Required.
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. ID for the profiler session.
    #[prost(string, tag = "2")]
    pub profiler_session_id: ::prost::alloc::string::String,
    /// Required. The Profiler Session to create.
    #[prost(message, optional, tag = "3")]
    pub profiler_session: ::core::option::Option<ProfilerSession>,
}
/// Request message for MachineLearningRuns.GetProfilerSession.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetProfilerSessionRequest {
    /// Required.
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}/profilerSessions/{profiler_session}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for listing profiler sessions.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListProfilerSessionsRequest {
    /// Required.
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of profiler sessions to return. The service
    /// may return fewer than this value. If unspecified, at most 10 profiler
    /// sessions will be returned. The maximum value is 1000; values above 1000
    /// will be coerced to 1000. Please refer to <https://google.aip.dev/158> for
    /// more details.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A page token, received from a previous `ListProfilerSessions`
    /// call. Provide this to retrieve the subsequent page. Please refer to
    /// <https://google.aip.dev/158> for more details.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for list profiler sessions.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProfilerSessionsResponse {
    /// A list of profiler sessions.
    #[prost(message, repeated, tag = "1")]
    pub profiler_sessions: ::prost::alloc::vec::Vec<ProfilerSession>,
    /// A token, which can be sent as `page_token` to retrieve the next page.
    /// If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for Deleting a ProfilerSession.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteProfilerSessionRequest {
    /// Required. The name of the profiler session to delete.
    /// Format:
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}/profilerSessions/{profiler_session}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for MachineLearningRuns.GetProfileSession.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetProfileSessionRequest {
    /// Required.
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}/profileSessions/{profileSession}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for MachineLearningRuns.ListProfileSessions.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListProfileSessionsRequest {
    /// Required. Parent format:
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of Profile Sessions to return. The service may
    /// return fewer than this value.
    /// If unspecified, at most 50 Profile Sessions will be returned.
    /// The maximum value is 1000; values above 1000 will be coerced to 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A page token, received from a previous `ListProfileSessions`
    /// call. Provide this to retrieve the subsequent page.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for MachineLearningRuns.ListProfileSessions.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListProfileSessionsResponse {
    /// A list of profile sessions.
    #[prost(message, repeated, tag = "1")]
    pub profile_sessions: ::prost::alloc::vec::Vec<ProfileSession>,
    /// A token, which can be sent as `page_token` to retrieve the next page.
    /// If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for CreateMonitoredEvent.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateMonitoredEventRequest {
    /// Required. Parent resource where the event will be created.
    /// Format:
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The event resource to create.
    #[prost(message, optional, tag = "2")]
    pub monitored_event: ::core::option::Option<MonitoredEvent>,
    /// Optional. Optional ID for the event.
    #[prost(string, tag = "3")]
    pub monitored_event_id: ::prost::alloc::string::String,
}
/// Request message for GetMonitoredEvent.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetMonitoredEventRequest {
    /// Required. The name of the monitored event to retrieve.
    /// Format:
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}/monitoredEvents/{monitored_event}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for ListMonitoredEvents.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListMonitoredEventsRequest {
    /// Required. Parent resource to list events from.
    /// Format:
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of events to return. The service may return
    /// fewer than this value. If unspecified, at most 50 events will be returned.
    /// The maximum value is 1000; values above 1000 will be coerced to 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A page token, received from a previous `ListMonitoredEvents`
    /// call. Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to `ListMonitoredEvents`
    /// must match the call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. A filter expression for filtering results.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Order by field for sorting results.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response message for ListMonitoredEvents.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListMonitoredEventsResponse {
    /// The list of monitored events.
    #[prost(message, repeated, tag = "1")]
    pub monitored_events: ::prost::alloc::vec::Vec<MonitoredEvent>,
    /// Token to retrieve the next page of results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for UpdateMonitoredEvent.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateMonitoredEventRequest {
    /// Required. The monitored event to update.
    ///
    /// The event's `name` field is used to identify the event to be updated.
    #[prost(message, optional, tag = "1")]
    pub monitored_event: ::core::option::Option<MonitoredEvent>,
    /// Optional. The list of fields to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for DeleteMonitoredEvent.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteMonitoredEventRequest {
    /// Required. The name of the monitored event to delete.
    /// Format:
    /// projects/{project}/locations/{location}/machineLearningRuns/{machine_learning_run}/monitoredEvents/{monitored_event}
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Configuration for a Machine Learning run.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Configs {
    /// Optional. Deprecated: userConfigs will be stored in Cloud Logging.
    /// User defined configs.
    #[prost(map = "string, string", tag = "1")]
    pub user_configs: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Software configs.
    #[prost(map = "string, string", tag = "2")]
    pub software_configs: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Hardware configs.
    #[prost(map = "string, string", tag = "3")]
    pub hardware_configs: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Deprecated: Use Cloud Logging to retrieve metrics information.
/// Metrics for a Machine Learning run.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct Metrics {
    /// Output only. Average step time.
    #[prost(message, optional, tag = "1")]
    pub avg_step: ::core::option::Option<::prost_types::Duration>,
    /// Output only. Average Model Flops Utilization (MFU).
    #[prost(float, tag = "2")]
    pub avg_mfu: f32,
    /// Output only. Average throughput. Value depends on the kind of workload ran
    /// on TPU.
    #[prost(float, tag = "3")]
    pub avg_throughput: f32,
    /// Output only. Average latency.
    #[prost(message, optional, tag = "4")]
    pub avg_latency: ::core::option::Option<::prost_types::Duration>,
    /// Output only. Average TPU TensorCore utilization.
    #[prost(float, tag = "5")]
    pub avg_tpu_tensorcore_utilization: f32,
    /// Output only. Average HBM (High Bandwidth Memory) utilization.
    #[prost(float, tag = "6")]
    pub avg_hbm_utilization: f32,
}
/// Represents information about the artifacts of the Machine Learning Run.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Artifacts {
    /// Optional. The Cloud Storage path where the artifacts of the run are stored.
    /// Example: `gs://my-bucket/my-run-directory`.
    #[prost(string, tag = "1")]
    pub gcs_path: ::prost::alloc::string::String,
}
/// A tool for a Machine Learning run.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Tool {
    /// tool - one of the diagnostic tool.
    #[prost(oneof = "tool::Tool", tags = "1, 2")]
    pub tool: ::core::option::Option<tool::Tool>,
}
/// Nested message and enum types in `Tool`.
pub mod tool {
    /// tool - one of the diagnostic tool.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Tool {
        /// Optional. XProf related metadata
        #[prost(message, tag = "1")]
        Xprof(super::Xprof),
        /// Optional. Smon (System Monitored) tool
        /// Signifies that the workload is under active monitoring.
        #[prost(message, tag = "2")]
        Smon(super::Smon),
    }
}
/// Workload details associated for the Machine Learning Run.
/// Workload have different metadata based on the orchestrator like
/// GKE cluster, Slurm cluster, Google Compute Engine instance etc.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorkloadDetails {
    /// The metadata for the workload for different orchestrators.
    #[prost(oneof = "workload_details::Metadata", tags = "1")]
    pub metadata: ::core::option::Option<workload_details::Metadata>,
}
/// Nested message and enum types in `WorkloadDetails`.
pub mod workload_details {
    /// The metadata for the workload for different orchestrators.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Metadata {
        /// GKE Workload metadata.
        #[prost(message, tag = "1")]
        Gke(super::GkeWorkloadDetails),
    }
}
/// Workload details for the GKE orchestrator.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GkeWorkloadDetails {
    /// Required. The identifier of the workload. Example - jobset-abcd
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Required. The kind of the workload. Possible values are JobSet,
    /// LeaderWorkerSet, RayCluster, RayJob, and Deployment.
    #[prost(string, tag = "2")]
    pub kind: ::prost::alloc::string::String,
    /// Required. The cluster of the workload.
    /// Example - projects/<project id>/locations/<location>/clusters/<cluster
    /// name>
    #[prost(string, tag = "3")]
    pub cluster: ::prost::alloc::string::String,
    /// Required. The namespace of the workload. Example - default
    #[prost(string, tag = "4")]
    pub namespace: ::prost::alloc::string::String,
    /// Optional. The parent workload. Example - JobSet for a Job, RayJob,
    /// LeaderWorkerSet etc. If a workload is a part of a RunSet, this field is
    /// populate as `RunSet` and if it was ray job, it will be set to `RayJob` etc.
    /// This will be an additional field to representing a workload.
    #[prost(string, tag = "5")]
    pub parent_workload: ::prost::alloc::string::String,
    /// Optional. labels for the workload.
    /// Example: {"type": "workload", "app": "simulation"}.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. Time when the workload was created.
    #[prost(message, optional, tag = "7")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// XProf related metadata
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Xprof {
    /// Required. XProf session id
    #[prost(string, tag = "1")]
    pub session_id: ::prost::alloc::string::String,
}
/// Smon Tool Metadata
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Smon {
    /// Output only. A summary of the monitoring findings.
    #[prost(string, tag = "1")]
    pub monitoring_summary: ::prost::alloc::string::String,
}
/// A detailed report from a specific analyzer.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnalyzerReport {
    /// Optional. Recommended actions to take.
    #[prost(message, repeated, tag = "4")]
    pub recommended_actions: ::prost::alloc::vec::Vec<RecommendedAction>,
    /// Required. Name of the system executed analyzer.
    /// Example - "Thermal Throttling Analyzer"
    #[prost(string, tag = "6")]
    pub analyzer: ::prost::alloc::string::String,
    /// Output only. Detection state produced by the analyzer.
    #[prost(enumeration = "analyzer_report::DetectionState", tag = "7")]
    pub detection_state: i32,
    /// Optional. A summary details of the analyzer findings.
    #[prost(string, tag = "8")]
    pub details: ::prost::alloc::string::String,
}
/// Nested message and enum types in `AnalyzerReport`.
pub mod analyzer_report {
    /// Represents the detection state of the analyzer.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DetectionState {
        /// Status is not specified.
        Unspecified = 0,
        /// Analyzer detected an issue.
        Detected = 1,
        /// Analyzer did not detect an issue.
        NotDetected = 2,
    }
    impl DetectionState {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "DETECTION_STATE_UNSPECIFIED",
                Self::Detected => "DETECTED",
                Self::NotDetected => "NOT_DETECTED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DETECTION_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "DETECTED" => Some(Self::Detected),
                "NOT_DETECTED" => Some(Self::NotDetected),
                _ => None,
            }
        }
    }
}
/// Represents a recommended action.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RecommendedAction {
    /// Optional. Description of the recommended action.
    /// The description can be up to 1024 characters long.
    #[prost(string, tag = "1")]
    pub description: ::prost::alloc::string::String,
    /// Optional. Optional link to documentation or more details about the action.
    #[prost(string, tag = "2")]
    pub documentation_url: ::prost::alloc::string::String,
}
/// State of the Machine Learning run.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum State {
    /// State is not specified.
    Unspecified = 0,
    /// Run is active.
    Active = 1,
    /// Run is completed.
    Completed = 2,
    /// Run is failed.
    Failed = 3,
}
impl State {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "STATE_UNSPECIFIED",
            Self::Active => "STATE_ACTIVE",
            Self::Completed => "STATE_COMPLETED",
            Self::Failed => "STATE_FAILED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "STATE_UNSPECIFIED" => Some(Self::Unspecified),
            "STATE_ACTIVE" => Some(Self::Active),
            "STATE_COMPLETED" => Some(Self::Completed),
            "STATE_FAILED" => Some(Self::Failed),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod machine_learning_runs_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service for managing Machine Learning Runs.
    #[derive(Debug, Clone)]
    pub struct MachineLearningRunsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl MachineLearningRunsClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> MachineLearningRunsClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> MachineLearningRunsClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            MachineLearningRunsClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Creates a Machine Learning Run.
        pub async fn create_machine_learning_run(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateMachineLearningRunRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/CreateMachineLearningRun",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "CreateMachineLearningRun",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an Machine Learning Run.
        pub async fn update_machine_learning_run(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateMachineLearningRunRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/UpdateMachineLearningRun",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "UpdateMachineLearningRun",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a Machine Learning Run.
        pub async fn delete_machine_learning_run(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteMachineLearningRunRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/DeleteMachineLearningRun",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "DeleteMachineLearningRun",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a Machine Learning Run.
        pub async fn get_machine_learning_run(
            &mut self,
            request: impl tonic::IntoRequest<super::GetMachineLearningRunRequest>,
        ) -> std::result::Result<
            tonic::Response<super::MachineLearningRun>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/GetMachineLearningRun",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "GetMachineLearningRun",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists Machine Learning Runs.
        pub async fn list_machine_learning_runs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListMachineLearningRunsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListMachineLearningRunsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/ListMachineLearningRuns",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "ListMachineLearningRuns",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a Profiler Target.
        pub async fn create_profiler_target(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateProfilerTargetRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/CreateProfilerTarget",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "CreateProfilerTarget",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a Profiler Target.
        pub async fn get_profiler_target(
            &mut self,
            request: impl tonic::IntoRequest<super::GetProfilerTargetRequest>,
        ) -> std::result::Result<tonic::Response<super::ProfilerTarget>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/GetProfilerTarget",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "GetProfilerTarget",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List Profiler Targets for a Machine Learning Run.
        pub async fn list_profiler_targets(
            &mut self,
            request: impl tonic::IntoRequest<super::ListProfilerTargetsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListProfilerTargetsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/ListProfilerTargets",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "ListProfilerTargets",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete a Profiler Target.
        pub async fn delete_profiler_target(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteProfilerTargetRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/DeleteProfilerTarget",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "DeleteProfilerTarget",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create a Profiler Session.
        pub async fn create_profiler_session(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateProfilerSessionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/CreateProfilerSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "CreateProfilerSession",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get Profiler Session.
        pub async fn get_profiler_session(
            &mut self,
            request: impl tonic::IntoRequest<super::GetProfilerSessionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ProfilerSession>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/GetProfilerSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "GetProfilerSession",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists Profiler Sessions for a Machine Learning Run.
        pub async fn list_profiler_sessions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListProfilerSessionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListProfilerSessionsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/ListProfilerSessions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "ListProfilerSessions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete a Profiler Session.
        pub async fn delete_profiler_session(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteProfilerSessionRequest>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/DeleteProfilerSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "DeleteProfilerSession",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deprecated: Use `GetProfilerSession` instead.
        /// Gets a Profile Session.
        #[deprecated]
        pub async fn get_profile_session(
            &mut self,
            request: impl tonic::IntoRequest<super::GetProfileSessionRequest>,
        ) -> std::result::Result<tonic::Response<super::ProfileSession>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/GetProfileSession",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "GetProfileSession",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deprecated: Use `ListProfilerSessions` instead.
        /// Lists Profile Sessions for a Machine Learning Run.
        #[deprecated]
        pub async fn list_profile_sessions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListProfileSessionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListProfileSessionsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/ListProfileSessions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "ListProfileSessions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a Monitored Event.
        pub async fn create_monitored_event(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateMonitoredEventRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/CreateMonitoredEvent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "CreateMonitoredEvent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a specific Monitored Event.
        pub async fn get_monitored_event(
            &mut self,
            request: impl tonic::IntoRequest<super::GetMonitoredEventRequest>,
        ) -> std::result::Result<tonic::Response<super::MonitoredEvent>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/GetMonitoredEvent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "GetMonitoredEvent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists Monitored Events for a run.
        pub async fn list_monitored_events(
            &mut self,
            request: impl tonic::IntoRequest<super::ListMonitoredEventsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListMonitoredEventsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/ListMonitoredEvents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "ListMonitoredEvents",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a Monitored Event.
        pub async fn update_monitored_event(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateMonitoredEventRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/UpdateMonitoredEvent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "UpdateMonitoredEvent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a Monitored Event.
        pub async fn delete_monitored_event(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteMonitoredEventRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns/DeleteMonitoredEvent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.hypercomputecluster.v1alpha.MachineLearningRuns",
                        "DeleteMonitoredEvent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Represents the metadata of the long-running operation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OperationMetadata {
    /// Output only. The time the operation was created.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the operation finished running.
    #[prost(message, optional, tag = "2")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Server-defined resource path for the target of the operation.
    #[prost(string, tag = "3")]
    pub target: ::prost::alloc::string::String,
    /// Output only. Name of the verb executed by the operation.
    #[prost(string, tag = "4")]
    pub verb: ::prost::alloc::string::String,
    /// Output only. Identifies whether the user has requested cancellation
    /// of the operation. Operations that have been cancelled successfully
    /// have
    /// \[google.longrunning.Operation.error\]\[google.longrunning.Operation.error\]
    /// value with a \[google.rpc.Status.code\]\[google.rpc.Status.code\] of `1`,
    /// corresponding to `Code.CANCELLED`.
    #[prost(bool, tag = "5")]
    pub requested_cancellation: bool,
    /// Output only. API version used to start the operation.
    #[prost(string, tag = "6")]
    pub api_version: ::prost::alloc::string::String,
    /// Output only. Progress of the operation.
    #[prost(message, optional, tag = "7")]
    pub progress: ::core::option::Option<OperationProgress>,
}
/// Message describing the progress of a cluster mutation long-running operation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OperationProgress {
    /// Output only. Steps and status of the operation.
    #[prost(message, repeated, tag = "1")]
    pub steps: ::prost::alloc::vec::Vec<OperationStep>,
}
/// Message describing the status of a single step in a cluster mutation
/// long-running operation.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OperationStep {
    /// Output only. State of the operation step.
    #[prost(enumeration = "operation_step::State", tag = "1")]
    pub state: i32,
    /// Step of the operation.
    #[prost(
        oneof = "operation_step::Type",
        tags = "2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26"
    )]
    pub r#type: ::core::option::Option<operation_step::Type>,
}
/// Nested message and enum types in `OperationStep`.
pub mod operation_step {
    /// State of the operation step.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Unspecified state.
        Unspecified = 0,
        /// Initial state before step execution starts.
        Waiting = 1,
        /// Step execution is running in progress.
        InProgress = 2,
        /// Step execution is completed.
        Done = 3,
    }
    impl State {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "STATE_UNSPECIFIED",
                Self::Waiting => "WAITING",
                Self::InProgress => "IN_PROGRESS",
                Self::Done => "DONE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "WAITING" => Some(Self::Waiting),
                "IN_PROGRESS" => Some(Self::InProgress),
                "DONE" => Some(Self::Done),
                _ => None,
            }
        }
    }
    /// Step of the operation.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Type {
        /// Output only. If set, indicates that new network creation is part of the
        /// operation.
        #[prost(message, tag = "2")]
        CreateNetwork(super::CreateNetwork),
        /// Output only. If set, indicates that new private service access creation
        /// is part of the operation.
        #[prost(message, tag = "3")]
        CreatePrivateServiceAccess(super::CreatePrivateServiceAccess),
        /// Output only. If set, indicates that new Filestore instance creation is
        /// part of the operation.
        #[prost(message, tag = "4")]
        CreateFilestoreInstance(super::CreateFilestoreInstance),
        /// Output only. If set, indicates that new Cloud Storage bucket creation is
        /// part of the operation.
        #[prost(message, tag = "5")]
        CreateStorageBucket(super::CreateStorageBucket),
        /// Output only. If set, indicates that new Lustre instance creation is part
        /// of the operation.
        #[prost(message, tag = "6")]
        CreateLustreInstance(super::CreateLustreInstance),
        /// Output only. If set, indicates that new GKE cluster creation is part of
        /// the operation.
        #[prost(message, tag = "7")]
        CreateGkeCluster(super::CreateGkeCluster),
        /// Output only. If set, indicates that orchestrator creation is part of the
        /// operation.
        #[prost(message, tag = "8")]
        CreateOrchestrator(super::CreateOrchestrator),
        /// Output only. If set, indicates that new nodeset creation is part of the
        /// operation.
        #[prost(message, tag = "9")]
        CreateNodeset(super::CreateNodeset),
        /// Output only. If set, indicates that new partition creation is part of the
        /// operation.
        #[prost(message, tag = "10")]
        CreatePartition(super::CreatePartition),
        /// Output only. If set, indicates that new login node creation is part of
        /// the operation.
        #[prost(message, tag = "11")]
        CreateLoginNode(super::CreateLoginNode),
        /// Output only. If set, indicates that cluster health check is part of the
        /// operation.
        #[prost(message, tag = "12")]
        CheckClusterHealth(super::CheckClusterHealth),
        /// Output only. If set, indicates that an orchestrator update is part of the
        /// operation.
        #[prost(message, tag = "13")]
        UpdateOrchestrator(super::UpdateOrchestrator),
        /// Output only. If set, indicates that nodeset update is part of the
        /// operation.
        #[prost(message, tag = "14")]
        UpdateNodeset(super::UpdateNodeset),
        /// Output only. If set, indicates that partition update is part of the
        /// operation.
        #[prost(message, tag = "15")]
        UpdatePartition(super::UpdatePartition),
        /// Output only. If set, indicates that login node update is part of the
        /// operation.
        #[prost(message, tag = "16")]
        UpdateLoginNode(super::UpdateLoginNode),
        /// Output only. If set, indicates that GKE cluster deletion is part of the
        /// operation.
        #[prost(message, tag = "17")]
        DeleteGkeCluster(super::DeleteGkeCluster),
        /// Output only. If set, indicates that orchestrator deletion is part of the
        /// operation.
        #[prost(message, tag = "18")]
        DeleteOrchestrator(super::DeleteOrchestrator),
        /// Output only. If set, indicates that nodeset deletion is part of the
        /// operation.
        #[prost(message, tag = "19")]
        DeleteNodeset(super::DeleteNodeset),
        /// Output only. If set, indicates that partition deletion is part of the
        /// operation.
        #[prost(message, tag = "20")]
        DeletePartition(super::DeletePartition),
        /// Output only. If set, indicates that login node deletion is part of the
        /// operation.
        #[prost(message, tag = "21")]
        DeleteLoginNode(super::DeleteLoginNode),
        /// Output only. If set, indicates that Filestore instance deletion is part
        /// of the operation.
        #[prost(message, tag = "22")]
        DeleteFilestoreInstance(super::DeleteFilestoreInstance),
        /// Output only. If set, indicates that Cloud Storage bucket deletion is part
        /// of the operation.
        #[prost(message, tag = "23")]
        DeleteStorageBucket(super::DeleteStorageBucket),
        /// Output only. If set, indicates that Lustre instance deletion is part of
        /// the operation.
        #[prost(message, tag = "24")]
        DeleteLustreInstance(super::DeleteLustreInstance),
        /// Output only. If set, indicates that private service access deletion is
        /// part of the operation.
        #[prost(message, tag = "25")]
        DeletePrivateServiceAccess(super::DeletePrivateServiceAccess),
        /// Output only. If set, indicates that network deletion is part of the
        /// operation.
        #[prost(message, tag = "26")]
        DeleteNetwork(super::DeleteNetwork),
    }
}
/// When set in OperationStep, indicates that a new network should be created.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateNetwork {
    /// Output only. Name of the network to create, in the format
    /// `projects/{project}/global/networks/{network}`.
    #[prost(string, tag = "1")]
    pub network: ::prost::alloc::string::String,
}
/// When set in OperationStep, indicates that a new private service access should
/// be created.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreatePrivateServiceAccess {}
/// When set in OperationStep, indicates that a new filestore instance should be
/// created.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateFilestoreInstance {
    /// Output only. Name of the Filestore instance, in the format
    /// `projects/{project}/locations/{location}/instances/{instance}`
    #[prost(string, tag = "1")]
    pub filestore: ::prost::alloc::string::String,
}
/// When set in OperationStep, indicates that a new storage bucket should be
/// created.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateStorageBucket {
    /// Output only. Name of the bucket.
    #[prost(string, tag = "1")]
    pub bucket: ::prost::alloc::string::String,
}
/// When set in OperationStep, indicates that a new lustre instance should be
/// created.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateLustreInstance {
    /// Output only. Name of the Managed Lustre instance, in the format
    /// `projects/{project}/locations/{location}/instances/{instance}`
    #[prost(string, tag = "1")]
    pub lustre: ::prost::alloc::string::String,
}
/// When set in OperationStep, indicates that a new GKE cluster should be
/// created.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateGkeCluster {
    /// Output only. Name of the GKE cluster.
    #[prost(string, tag = "1")]
    pub cluster: ::prost::alloc::string::String,
}
/// When set in OperationStep, indicates that an orchestrator should be created.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateOrchestrator {}
/// When set in OperationStep, indicates that a nodeset should be created.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateNodeset {
    /// Output only. Name of the nodeset to create
    #[prost(string, repeated, tag = "1")]
    pub nodesets: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// When set in OperationStep, indicates that a partition should be created.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreatePartition {
    /// Output only. Name of the partition to create
    #[prost(string, repeated, tag = "1")]
    pub partitions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// When set in OperationStep, indicates that a login node should be created.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateLoginNode {}
/// When set in OperationStep, indicates that cluster health check should be
/// performed.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CheckClusterHealth {}
/// When set in OperationStep, indicates that an orchestrator should be updated.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateOrchestrator {}
/// When set in OperationStep, indicates that a nodeset should be updated.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateNodeset {
    /// Output only. Name of the nodeset to update
    #[prost(string, repeated, tag = "1")]
    pub nodesets: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// When set in OperationStep, indicates that a partition should be updated.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdatePartition {
    /// Output only. Name of the partition to update
    #[prost(string, repeated, tag = "1")]
    pub partitions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// When set in OperationStep, indicates that a login node should be updated.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateLoginNode {}
/// When set in OperationStep, indicates that a GKE cluster should be
/// deleted.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteGkeCluster {
    /// Output only. Name of the GKE cluster.
    #[prost(string, tag = "1")]
    pub cluster: ::prost::alloc::string::String,
}
/// When set in OperationStep, indicates that an orchestrator should be deleted.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteOrchestrator {}
/// When set in OperationStep, indicates that a nodeset should be deleted.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteNodeset {
    /// Output only. Name of the nodeset to delete
    #[prost(string, repeated, tag = "1")]
    pub nodesets: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// When set in OperationStep, indicates that a partition should be deleted.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeletePartition {
    /// Output only. Name of the partition to delete
    #[prost(string, repeated, tag = "1")]
    pub partitions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// When set in OperationStep, indicates that a login node should be deleted.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteLoginNode {}
/// When set in OperationStep, indicates that a Filestore instance should be
/// deleted.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteFilestoreInstance {
    /// Output only. Name of the Filestore instance, in the format
    /// `projects/{project}/locations/{location}/instances/{instance}`
    #[prost(string, tag = "1")]
    pub filestore: ::prost::alloc::string::String,
}
/// When set in OperationStep, indicates that Cloud Storage bucket should be
/// deleted.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteStorageBucket {
    /// Output only. Name of the bucket.
    #[prost(string, tag = "1")]
    pub bucket: ::prost::alloc::string::String,
}
/// When set in OperationStep, indicates that a Lustre instance should be
/// deleted.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteLustreInstance {
    /// Output only. Name of the Managed Lustre instance, in the format
    /// `projects/{project}/locations/{location}/instances/{instance}`
    #[prost(string, tag = "1")]
    pub lustre: ::prost::alloc::string::String,
}
/// When set in OperationStep, indicates private service access deletion
/// step.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeletePrivateServiceAccess {}
/// When set in OperationStep, indicates network deletion step with the
/// resource name.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteNetwork {
    /// Output only. Name of the network to delete, in the format
    /// `projects/{project}/global/networks/{network}`.
    #[prost(string, tag = "1")]
    pub network: ::prost::alloc::string::String,
}