yandex-cloud 2025.4.14

#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Resources {
    /// ID of the resource preset for computational resources available to a host (CPU, memory etc.).
    /// All available presets are listed in the \[documentation\](/docs/data-proc/concepts/instance-types).
    #[prost(string, tag = "1")]
    pub resource_preset_id: ::prost::alloc::string::String,
    /// Type of the storage environment for the host.
    /// Possible values:
    /// * network-hdd - network HDD drive,
    /// * network-ssd - network SSD drive.
    #[prost(string, tag = "2")]
    pub disk_type_id: ::prost::alloc::string::String,
    /// Volume of the storage available to a host, in bytes.
    #[prost(int64, tag = "3")]
    pub disk_size: i64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Health {
    /// Object is in unknown state (we have no data).
    Unknown = 0,
    /// Object is alive and well (for example, all hosts of the cluster are alive).
    Alive = 1,
    /// Object is inoperable (it cannot perform any of its essential functions).
    Dead = 2,
    /// Object is partially alive (it can perform some of its essential functions).
    Degraded = 3,
}
impl Health {
    /// 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 {
            Health::Unknown => "HEALTH_UNKNOWN",
            Health::Alive => "ALIVE",
            Health::Dead => "DEAD",
            Health::Degraded => "DEGRADED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "HEALTH_UNKNOWN" => Some(Self::Unknown),
            "ALIVE" => Some(Self::Alive),
            "DEAD" => Some(Self::Dead),
            "DEGRADED" => Some(Self::Degraded),
            _ => None,
        }
    }
}
/// A Yandex Data Processing cluster. For details about the concept, see \[documentation\](/docs/data-proc/concepts/).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Cluster {
    /// ID of the cluster. Generated at creation time.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the cluster belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Creation timestamp.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the cluster. The name is unique within the folder.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the cluster.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Cluster labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Monitoring systems relevant to the cluster.
    #[prost(message, repeated, tag = "7")]
    pub monitoring: ::prost::alloc::vec::Vec<Monitoring>,
    /// Configuration of the cluster.
    #[prost(message, optional, tag = "8")]
    pub config: ::core::option::Option<ClusterConfig>,
    /// Aggregated cluster health.
    #[prost(enumeration = "Health", tag = "9")]
    pub health: i32,
    /// Cluster status.
    #[prost(enumeration = "cluster::Status", tag = "10")]
    pub status: i32,
    /// ID of the availability zone where the cluster resides.
    #[prost(string, tag = "11")]
    pub zone_id: ::prost::alloc::string::String,
    /// ID of service account for the Yandex Data Processing manager agent.
    #[prost(string, tag = "12")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Object Storage bucket to be used for Yandex Data Processing jobs that are run in the cluster.
    #[prost(string, tag = "13")]
    pub bucket: ::prost::alloc::string::String,
    /// Whether UI Proxy feature is enabled.
    #[prost(bool, tag = "14")]
    pub ui_proxy: bool,
    /// User security groups.
    #[prost(string, repeated, tag = "15")]
    pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Host groups hosting VMs of the cluster.
    #[prost(string, repeated, tag = "16")]
    pub host_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Deletion Protection inhibits deletion of the cluster
    #[prost(bool, tag = "17")]
    pub deletion_protection: bool,
    /// ID of the cloud logging log group to write logs. If not set, default log group for the folder will be used.
    /// To prevent logs from being sent to the cloud set cluster property dataproc:disable_cloud_logging = true
    #[prost(string, tag = "18")]
    pub log_group_id: ::prost::alloc::string::String,
    /// Environment of the cluster
    #[prost(enumeration = "cluster::Environment", tag = "19")]
    pub environment: i32,
}
/// Nested message and enum types in `Cluster`.
pub mod cluster {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        /// Cluster state is unknown.
        Unknown = 0,
        /// Cluster is being created.
        Creating = 1,
        /// Cluster is running normally.
        Running = 2,
        /// Cluster encountered a problem and cannot operate.
        Error = 3,
        /// Cluster is stopping.
        Stopping = 4,
        /// Cluster stopped.
        Stopped = 5,
        /// Cluster is starting.
        Starting = 6,
    }
    impl Status {
        /// 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 {
                Status::Unknown => "STATUS_UNKNOWN",
                Status::Creating => "CREATING",
                Status::Running => "RUNNING",
                Status::Error => "ERROR",
                Status::Stopping => "STOPPING",
                Status::Stopped => "STOPPED",
                Status::Starting => "STARTING",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_UNKNOWN" => Some(Self::Unknown),
                "CREATING" => Some(Self::Creating),
                "RUNNING" => Some(Self::Running),
                "ERROR" => Some(Self::Error),
                "STOPPING" => Some(Self::Stopping),
                "STOPPED" => Some(Self::Stopped),
                "STARTING" => Some(Self::Starting),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Environment {
        Unspecified = 0,
        Production = 1,
        Prestable = 2,
    }
    impl Environment {
        /// 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 {
                Environment::Unspecified => "ENVIRONMENT_UNSPECIFIED",
                Environment::Production => "PRODUCTION",
                Environment::Prestable => "PRESTABLE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ENVIRONMENT_UNSPECIFIED" => Some(Self::Unspecified),
                "PRODUCTION" => Some(Self::Production),
                "PRESTABLE" => Some(Self::Prestable),
                _ => None,
            }
        }
    }
}
/// Metadata of a monitoring system for a Yandex Data Processing cluster.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Monitoring {
    /// Name of the monitoring system.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Description of the monitoring system.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Link to the monitoring system.
    #[prost(string, tag = "3")]
    pub link: ::prost::alloc::string::String,
}
/// Hadoop configuration that describes services installed in a cluster,
/// their properties and settings.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HadoopConfig {
    /// Set of services used in the cluster (if empty, the default set is used).
    #[prost(enumeration = "hadoop_config::Service", repeated, tag = "1")]
    pub services: ::prost::alloc::vec::Vec<i32>,
    /// Properties set for all hosts in `*-site.xml` configurations. The key should indicate
    /// the service and the property.
    ///
    /// For example, use the key 'hdfs:dfs.replication' to set the `dfs.replication` property
    /// in the file `/etc/hadoop/conf/hdfs-site.xml`.
    #[prost(map = "string, string", tag = "2")]
    pub properties: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// List of public SSH keys to access to cluster hosts.
    #[prost(string, repeated, tag = "3")]
    pub ssh_public_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Set of init-actions
    #[prost(message, repeated, tag = "4")]
    pub initialization_actions: ::prost::alloc::vec::Vec<InitializationAction>,
}
/// Nested message and enum types in `HadoopConfig`.
pub mod hadoop_config {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Service {
        Unspecified = 0,
        Hdfs = 1,
        Yarn = 2,
        Mapreduce = 3,
        Hive = 4,
        Tez = 5,
        Zookeeper = 6,
        Hbase = 7,
        Sqoop = 8,
        Flume = 9,
        Spark = 10,
        Zeppelin = 11,
        Oozie = 12,
        Livy = 13,
    }
    impl Service {
        /// 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 {
                Service::Unspecified => "SERVICE_UNSPECIFIED",
                Service::Hdfs => "HDFS",
                Service::Yarn => "YARN",
                Service::Mapreduce => "MAPREDUCE",
                Service::Hive => "HIVE",
                Service::Tez => "TEZ",
                Service::Zookeeper => "ZOOKEEPER",
                Service::Hbase => "HBASE",
                Service::Sqoop => "SQOOP",
                Service::Flume => "FLUME",
                Service::Spark => "SPARK",
                Service::Zeppelin => "ZEPPELIN",
                Service::Oozie => "OOZIE",
                Service::Livy => "LIVY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SERVICE_UNSPECIFIED" => Some(Self::Unspecified),
                "HDFS" => Some(Self::Hdfs),
                "YARN" => Some(Self::Yarn),
                "MAPREDUCE" => Some(Self::Mapreduce),
                "HIVE" => Some(Self::Hive),
                "TEZ" => Some(Self::Tez),
                "ZOOKEEPER" => Some(Self::Zookeeper),
                "HBASE" => Some(Self::Hbase),
                "SQOOP" => Some(Self::Sqoop),
                "FLUME" => Some(Self::Flume),
                "SPARK" => Some(Self::Spark),
                "ZEPPELIN" => Some(Self::Zeppelin),
                "OOZIE" => Some(Self::Oozie),
                "LIVY" => Some(Self::Livy),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClusterConfig {
    /// Image version for cluster provisioning.
    /// All available versions are listed in the \[documentation\](/docs/data-proc/concepts/environment).
    #[prost(string, tag = "1")]
    pub version_id: ::prost::alloc::string::String,
    /// Yandex Data Processing specific configuration options.
    #[prost(message, optional, tag = "2")]
    pub hadoop: ::core::option::Option<HadoopConfig>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InitializationAction {
    /// URI of the executable file
    #[prost(string, tag = "1")]
    pub uri: ::prost::alloc::string::String,
    /// Arguments to the initialization action
    #[prost(string, repeated, tag = "2")]
    pub args: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Execution timeout
    #[prost(int64, tag = "3")]
    pub timeout: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutoscalingConfig {
    /// Upper limit for total instance subcluster count.
    #[prost(int64, tag = "1")]
    pub max_hosts_count: i64,
    /// Preemptible instances are stopped at least once every 24 hours, and can be stopped at any time
    /// if their resources are needed by Compute.
    /// For more information, see [Preemptible Virtual Machines](/docs/compute/concepts/preemptible-vm).
    #[prost(bool, tag = "2")]
    pub preemptible: bool,
    /// Time in seconds allotted for averaging metrics.
    #[prost(message, optional, tag = "3")]
    pub measurement_duration: ::core::option::Option<::prost_types::Duration>,
    /// The warmup time of the instance in seconds. During this time,
    /// traffic is sent to the instance, but instance metrics are not collected.
    #[prost(message, optional, tag = "4")]
    pub warmup_duration: ::core::option::Option<::prost_types::Duration>,
    /// Minimum amount of time in seconds allotted for monitoring before
    /// Instance Groups can reduce the number of instances in the group.
    /// During this time, the group size doesn't decrease, even if the new metric values
    /// indicate that it should.
    #[prost(message, optional, tag = "5")]
    pub stabilization_duration: ::core::option::Option<::prost_types::Duration>,
    /// Defines an autoscaling rule based on the average CPU utilization of the instance group.
    #[prost(double, tag = "6")]
    pub cpu_utilization_target: f64,
    /// Timeout to gracefully decommission nodes during downscaling. In seconds. Default value: 120
    #[prost(int64, tag = "7")]
    pub decommission_timeout: i64,
}
/// A Yandex Data Processing subcluster. For details about the concept, see \[documentation\](/docs/data-proc/concepts/).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Subcluster {
    /// ID of the subcluster. Generated at creation time.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the Yandex Data Processing cluster that the subcluster belongs to.
    #[prost(string, tag = "2")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Creation timestamp.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the subcluster. The name is unique within the cluster.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Role that is fulfilled by hosts of the subcluster.
    #[prost(enumeration = "Role", tag = "5")]
    pub role: i32,
    /// Resources allocated for each host in the subcluster.
    #[prost(message, optional, tag = "6")]
    pub resources: ::core::option::Option<Resources>,
    /// ID of the VPC subnet used for hosts in the subcluster.
    #[prost(string, tag = "7")]
    pub subnet_id: ::prost::alloc::string::String,
    /// Number of hosts in the subcluster.
    #[prost(int64, tag = "8")]
    pub hosts_count: i64,
    /// Assign public ip addresses for all hosts in subcluter.
    #[prost(bool, tag = "9")]
    pub assign_public_ip: bool,
    /// Configuration for instance group based subclusters
    #[prost(message, optional, tag = "10")]
    pub autoscaling_config: ::core::option::Option<AutoscalingConfig>,
    /// ID of Compute Instance Group for autoscaling subclusters
    #[prost(string, tag = "11")]
    pub instance_group_id: ::prost::alloc::string::String,
}
/// A Yandex Data Processing host. For details about the concept, see \[documentation\](/docs/data-proc/concepts/).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Host {
    /// Name of the Yandex Data Processing host. The host name is assigned by Yandex Data Processing at creation time
    /// and cannot be changed. The name is generated to be unique across all Yandex Data Processing
    /// hosts that exist on the platform, as it defines the FQDN of the host.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// ID of the Yandex Data Processing subcluster that the host belongs to.
    #[prost(string, tag = "2")]
    pub subcluster_id: ::prost::alloc::string::String,
    /// Status code of the aggregated health of the host.
    #[prost(enumeration = "Health", tag = "3")]
    pub health: i32,
    /// ID of the Compute virtual machine that is used as the Yandex Data Processing host.
    #[prost(string, tag = "4")]
    pub compute_instance_id: ::prost::alloc::string::String,
    /// Role of the host in the cluster.
    #[prost(enumeration = "Role", tag = "5")]
    pub role: i32,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Role {
    Unspecified = 0,
    /// The subcluster fulfills the master role.
    ///
    /// Master can run the following services, depending on the requested components:
    /// * HDFS: Namenode, Secondary Namenode
    /// * YARN: ResourceManager, Timeline Server
    /// * HBase Master
    /// * Hive: Server, Metastore, HCatalog
    /// * Spark History Server
    /// * Zeppelin
    /// * ZooKeeper
    Masternode = 1,
    /// The subcluster is a DATANODE in a Yandex Data Processing cluster.
    ///
    /// DATANODE can run the following services, depending on the requested components:
    /// * HDFS DataNode
    /// * YARN NodeManager
    /// * HBase RegionServer
    /// * Spark libraries
    Datanode = 2,
    /// The subcluster is a COMPUTENODE in a Yandex Data Processing cluster.
    ///
    /// COMPUTENODE can run the following services, depending on the requested components:
    /// * YARN NodeManager
    /// * Spark libraries
    Computenode = 3,
}
impl Role {
    /// 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 {
            Role::Unspecified => "ROLE_UNSPECIFIED",
            Role::Masternode => "MASTERNODE",
            Role::Datanode => "DATANODE",
            Role::Computenode => "COMPUTENODE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ROLE_UNSPECIFIED" => Some(Self::Unspecified),
            "MASTERNODE" => Some(Self::Masternode),
            "DATANODE" => Some(Self::Datanode),
            "COMPUTENODE" => Some(Self::Computenode),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetClusterRequest {
    /// ID of the Yandex Data Processing cluster.
    ///
    /// To get a cluster ID make a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClustersRequest {
    /// ID of the folder to list clusters in.
    ///
    /// To get the folder ID make a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\], the service returns a \[ListClustersResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `page_token` to the
    /// \[ListClustersResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters clusters listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently you can use filtering only on \[Cluster.name\] field.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// Example of a filter: `name=my-cluster`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClustersResponse {
    /// List of clusters in the specified folder.
    #[prost(message, repeated, tag = "1")]
    pub clusters: ::prost::alloc::vec::Vec<Cluster>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListClustersRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListClustersRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSubclusterConfigSpec {
    /// Name of the subcluster.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Role of the subcluster in the Yandex Data Processing cluster.
    #[prost(enumeration = "Role", tag = "2")]
    pub role: i32,
    /// Resource configuration for hosts in the subcluster.
    #[prost(message, optional, tag = "3")]
    pub resources: ::core::option::Option<Resources>,
    /// ID of the VPC subnet used for hosts in the subcluster.
    #[prost(string, tag = "4")]
    pub subnet_id: ::prost::alloc::string::String,
    /// Number of hosts in the subcluster.
    #[prost(int64, tag = "5")]
    pub hosts_count: i64,
    /// Assign public ip addresses for all hosts in subcluter.
    #[prost(bool, tag = "6")]
    pub assign_public_ip: bool,
    /// Configuration for instance group based subclusters
    #[prost(message, optional, tag = "7")]
    pub autoscaling_config: ::core::option::Option<AutoscalingConfig>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSubclusterConfigSpec {
    /// ID of the subcluster to update.
    ///
    /// To get the subcluster ID make a \[SubclusterService.List\] request.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Name of the subcluster.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Resource configuration for each host in the subcluster.
    #[prost(message, optional, tag = "3")]
    pub resources: ::core::option::Option<Resources>,
    /// Number of hosts in the subcluster.
    #[prost(int64, tag = "4")]
    pub hosts_count: i64,
    /// Configuration for instance group based subclusters
    #[prost(message, optional, tag = "5")]
    pub autoscaling_config: ::core::option::Option<AutoscalingConfig>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateClusterConfigSpec {
    /// Version of the image for cluster provisioning.
    ///
    /// All available versions are listed in the \[documentation\](/docs/data-proc/concepts/environment).
    #[prost(string, tag = "1")]
    pub version_id: ::prost::alloc::string::String,
    /// Yandex Data Processing specific options.
    #[prost(message, optional, tag = "2")]
    pub hadoop: ::core::option::Option<HadoopConfig>,
    /// Specification for creating subclusters.
    #[prost(message, repeated, tag = "3")]
    pub subclusters_spec: ::prost::alloc::vec::Vec<CreateSubclusterConfigSpec>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateClusterConfigSpec {
    /// New configuration for subclusters in a cluster.
    #[prost(message, repeated, tag = "1")]
    pub subclusters_spec: ::prost::alloc::vec::Vec<UpdateSubclusterConfigSpec>,
    /// Hadoop specific options
    #[prost(message, optional, tag = "2")]
    pub hadoop: ::core::option::Option<HadoopConfig>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateClusterRequest {
    /// ID of the folder to create a cluster in.
    ///
    /// To get a folder ID make a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the cluster. The name must be unique within the folder.
    /// The name can't be changed after the Yandex Data Processing cluster is created.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the cluster.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Cluster labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Configuration and resources for hosts that should be created with the cluster.
    #[prost(message, optional, tag = "6")]
    pub config_spec: ::core::option::Option<CreateClusterConfigSpec>,
    /// ID of the availability zone where the cluster should be placed.
    ///
    /// To get the list of available zones make a \[yandex.cloud.compute.v1.ZoneService.List\] request.
    #[prost(string, tag = "7")]
    pub zone_id: ::prost::alloc::string::String,
    /// ID of the service account to be used by the Yandex Data Processing manager agent.
    #[prost(string, tag = "8")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Name of the Object Storage bucket to use for Yandex Data Processing jobs.
    #[prost(string, tag = "9")]
    pub bucket: ::prost::alloc::string::String,
    /// Enable UI Proxy feature.
    #[prost(bool, tag = "10")]
    pub ui_proxy: bool,
    /// User security groups.
    #[prost(string, repeated, tag = "11")]
    pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Host groups to place VMs of cluster on.
    #[prost(string, repeated, tag = "12")]
    pub host_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Deletion Protection inhibits deletion of the cluster
    #[prost(bool, tag = "13")]
    pub deletion_protection: bool,
    /// ID of the cloud logging log group to write logs. If not set, logs will not be sent to logging service
    #[prost(string, tag = "14")]
    pub log_group_id: ::prost::alloc::string::String,
    /// Environment of the cluster
    #[prost(enumeration = "cluster::Environment", tag = "15")]
    pub environment: i32,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateClusterMetadata {
    /// ID of the cluster that is being created.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateClusterRequest {
    /// ID of the cluster to update.
    ///
    /// To get the cluster ID, make a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Field mask that specifies which attributes of the cluster should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New description for the cluster.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// A new set of cluster labels as `key:value` pairs.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Configuration and resources for hosts that should be created with the Yandex Data Processing cluster.
    #[prost(message, optional, tag = "5")]
    pub config_spec: ::core::option::Option<UpdateClusterConfigSpec>,
    /// New name for the Yandex Data Processing cluster. The name must be unique within the folder.
    #[prost(string, tag = "6")]
    pub name: ::prost::alloc::string::String,
    /// ID of the new service account to be used by the Yandex Data Processing manager agent.
    #[prost(string, tag = "7")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Name of the new Object Storage bucket to use for Yandex Data Processing jobs.
    #[prost(string, tag = "8")]
    pub bucket: ::prost::alloc::string::String,
    /// Timeout to gracefully decommission nodes. In seconds. Default value: 0
    #[prost(int64, tag = "9")]
    pub decommission_timeout: i64,
    /// Enable UI Proxy feature.
    #[prost(bool, tag = "10")]
    pub ui_proxy: bool,
    /// User security groups.
    #[prost(string, repeated, tag = "11")]
    pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Deletion Protection inhibits deletion of the cluster
    #[prost(bool, tag = "12")]
    pub deletion_protection: bool,
    /// ID of the cloud logging log group to write logs. If not set, logs will not be sent to logging service
    #[prost(string, tag = "13")]
    pub log_group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateClusterMetadata {
    /// ID of the cluster that is being updated.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteClusterRequest {
    /// ID of the cluster to delete.
    ///
    /// To get a cluster ID, make a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Timeout to gracefully decommission nodes. In seconds. Default value: 0
    #[prost(int64, tag = "2")]
    pub decommission_timeout: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteClusterMetadata {
    /// ID of the Yandex Data Processing cluster that is being deleted.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartClusterRequest {
    /// ID of the cluster to start.
    ///
    /// To get a cluster ID, make a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartClusterMetadata {
    /// ID of the Yandex Data Processing cluster that is being started.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StopClusterRequest {
    /// ID of the cluster to stop.
    ///
    /// To get a cluster ID, make a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Timeout to gracefully decommission nodes. In seconds. Default value: 0
    #[prost(int64, tag = "2")]
    pub decommission_timeout: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StopClusterMetadata {
    /// ID of the Yandex Data Processing cluster that is being stopped.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterOperationsRequest {
    /// ID of the cluster to list operations for.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\], the service returns a \[ListClusterOperationsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the
    /// \[ListClusterOperationsResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterOperationsResponse {
    /// List of operations for the specified cluster.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListClusterOperationsRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListClusterOperationsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterHostsRequest {
    /// ID of the cluster to list hosts for.
    ///
    /// To get a cluster ID, make a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\], the service returns a \[ListClusterHostsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the
    /// \[ListClusterHostsResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters hosts listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently you can use filtering only on \[Cluster.name\] field.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// Example of a filter: `name=my-host`
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterHostsResponse {
    /// Requested list of hosts.
    #[prost(message, repeated, tag = "1")]
    pub hosts: ::prost::alloc::vec::Vec<Host>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListClusterHostsRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListClusterHostsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListUiLinksRequest {
    /// Required. ID of the Hadoop cluster.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UiLink {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub url: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListUiLinksResponse {
    /// Requested list of ui links.
    #[prost(message, repeated, tag = "1")]
    pub links: ::prost::alloc::vec::Vec<UiLink>,
}
/// Generated client implementations.
pub mod cluster_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing Yandex Data Processing clusters.
    #[derive(Debug, Clone)]
    pub struct ClusterServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ClusterServiceClient<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> ClusterServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> ClusterServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            ClusterServiceClient::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
        }
        /// Returns the specified cluster.
        ///
        /// To get the list of all available clusters, make a [ClusterService.List] request.
        pub async fn get(
            &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::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.ClusterService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.dataproc.v1.ClusterService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of clusters in the specified folder.
        pub async fn list(
            &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::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.ClusterService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.dataproc.v1.ClusterService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a cluster in the specified folder.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.ClusterService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.dataproc.v1.ClusterService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the configuration of the specified cluster.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.ClusterService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.dataproc.v1.ClusterService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified cluster.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.ClusterService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.dataproc.v1.ClusterService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Starts the specified cluster.
        pub async fn start(
            &mut self,
            request: impl tonic::IntoRequest<super::StartClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.ClusterService/Start",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.dataproc.v1.ClusterService", "Start"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Stops the specified cluster.
        pub async fn stop(
            &mut self,
            request: impl tonic::IntoRequest<super::StopClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.ClusterService/Stop",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.dataproc.v1.ClusterService", "Stop"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists operations for the specified cluster.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListClusterOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListClusterOperationsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.ClusterService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.dataproc.v1.ClusterService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of hosts in the specified cluster.
        pub async fn list_hosts(
            &mut self,
            request: impl tonic::IntoRequest<super::ListClusterHostsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListClusterHostsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.ClusterService/ListHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.dataproc.v1.ClusterService",
                        "ListHosts",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves a list of links to web interfaces being proxied by Yandex Data Processing UI Proxy.
        pub async fn list_ui_links(
            &mut self,
            request: impl tonic::IntoRequest<super::ListUiLinksRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListUiLinksResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.ClusterService/ListUILinks",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.dataproc.v1.ClusterService",
                        "ListUILinks",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A Yandex Data Processing job. For details about the concept, see \[documentation\](/docs/data-proc/concepts/jobs).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Job {
    /// ID of the job. Generated at creation time.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the Yandex Data Processing cluster that the job belongs to.
    #[prost(string, tag = "2")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Creation timestamp.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// The time when the job was started.
    #[prost(message, optional, tag = "4")]
    pub started_at: ::core::option::Option<::prost_types::Timestamp>,
    /// The time when the job was finished.
    #[prost(message, optional, tag = "5")]
    pub finished_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the job, specified in the \[JobService.Create\] request.
    #[prost(string, tag = "6")]
    pub name: ::prost::alloc::string::String,
    /// The id of the user who created the job
    #[prost(string, tag = "12")]
    pub created_by: ::prost::alloc::string::String,
    /// Job status.
    #[prost(enumeration = "job::Status", tag = "7")]
    pub status: i32,
    /// Attributes of YARN application.
    #[prost(message, optional, tag = "13")]
    pub application_info: ::core::option::Option<ApplicationInfo>,
    /// Specification for the job.
    #[prost(oneof = "job::JobSpec", tags = "8, 9, 10, 11")]
    pub job_spec: ::core::option::Option<job::JobSpec>,
}
/// Nested message and enum types in `Job`.
pub mod job {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        Unspecified = 0,
        /// Job is logged in the database and is waiting for the agent to run it.
        Provisioning = 1,
        /// Job is acquired by the agent and is in the queue for execution.
        Pending = 2,
        /// Job is being run in the cluster.
        Running = 3,
        /// Job failed to finish the run properly.
        Error = 4,
        /// Job is finished.
        Done = 5,
        /// Job is cancelled.
        Cancelled = 6,
        /// Job is waiting for cancellation.
        Cancelling = 7,
    }
    impl Status {
        /// 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 {
                Status::Unspecified => "STATUS_UNSPECIFIED",
                Status::Provisioning => "PROVISIONING",
                Status::Pending => "PENDING",
                Status::Running => "RUNNING",
                Status::Error => "ERROR",
                Status::Done => "DONE",
                Status::Cancelled => "CANCELLED",
                Status::Cancelling => "CANCELLING",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "PROVISIONING" => Some(Self::Provisioning),
                "PENDING" => Some(Self::Pending),
                "RUNNING" => Some(Self::Running),
                "ERROR" => Some(Self::Error),
                "DONE" => Some(Self::Done),
                "CANCELLED" => Some(Self::Cancelled),
                "CANCELLING" => Some(Self::Cancelling),
                _ => None,
            }
        }
    }
    /// Specification for the job.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum JobSpec {
        /// Specification for a MapReduce job.
        #[prost(message, tag = "8")]
        MapreduceJob(super::MapreduceJob),
        /// Specification for a Spark job.
        #[prost(message, tag = "9")]
        SparkJob(super::SparkJob),
        /// Specification for a PySpark job.
        #[prost(message, tag = "10")]
        PysparkJob(super::PysparkJob),
        /// Specification for a Hive job.
        #[prost(message, tag = "11")]
        HiveJob(super::HiveJob),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApplicationAttempt {
    /// ID of YARN application attempt
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of YARN Application Master container
    #[prost(string, tag = "2")]
    pub am_container_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApplicationInfo {
    /// ID of YARN application
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// YARN application attempts
    #[prost(message, repeated, tag = "2")]
    pub application_attempts: ::prost::alloc::vec::Vec<ApplicationAttempt>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MapreduceJob {
    /// Optional arguments to pass to the driver.
    #[prost(string, repeated, tag = "1")]
    pub args: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// JAR file URIs to add to CLASSPATH of the Yandex Data Processing driver and each task.
    #[prost(string, repeated, tag = "2")]
    pub jar_file_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// URIs of resource files to be copied to the working directory of Yandex Data Processing drivers
    /// and distributed Hadoop tasks.
    #[prost(string, repeated, tag = "3")]
    pub file_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// URIs of archives to be extracted to the working directory of Yandex Data Processing drivers and tasks.
    #[prost(string, repeated, tag = "4")]
    pub archive_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Property names and values, used to configure Yandex Data Processing and MapReduce.
    #[prost(map = "string, string", tag = "5")]
    pub properties: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    #[prost(oneof = "mapreduce_job::Driver", tags = "6, 7")]
    pub driver: ::core::option::Option<mapreduce_job::Driver>,
}
/// Nested message and enum types in `MapreduceJob`.
pub mod mapreduce_job {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Driver {
        /// HCFS URI of the .jar file containing the driver class.
        #[prost(string, tag = "6")]
        MainJarFileUri(::prost::alloc::string::String),
        /// The name of the driver class.
        #[prost(string, tag = "7")]
        MainClass(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SparkJob {
    /// Optional arguments to pass to the driver.
    #[prost(string, repeated, tag = "1")]
    pub args: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// JAR file URIs to add to CLASSPATH of the Yandex Data Processing driver and each task.
    #[prost(string, repeated, tag = "2")]
    pub jar_file_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// URIs of resource files to be copied to the working directory of Yandex Data Processing drivers
    /// and distributed Hadoop tasks.
    #[prost(string, repeated, tag = "3")]
    pub file_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// URIs of archives to be extracted to the working directory of Yandex Data Processing drivers and tasks.
    #[prost(string, repeated, tag = "4")]
    pub archive_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Property names and values, used to configure Yandex Data Processing and Spark.
    #[prost(map = "string, string", tag = "5")]
    pub properties: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// The HCFS URI of the JAR file containing the `main` class for the job.
    #[prost(string, tag = "6")]
    pub main_jar_file_uri: ::prost::alloc::string::String,
    /// The name of the driver class.
    #[prost(string, tag = "7")]
    pub main_class: ::prost::alloc::string::String,
    /// List of maven coordinates of jars to include on the driver and executor classpaths.
    #[prost(string, repeated, tag = "8")]
    pub packages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// List of additional remote repositories to search for the maven coordinates given with --packages.
    #[prost(string, repeated, tag = "9")]
    pub repositories: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// List of groupId:artifactId, to exclude while resolving the dependencies provided in --packages to avoid dependency conflicts.
    #[prost(string, repeated, tag = "10")]
    pub exclude_packages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PysparkJob {
    /// Optional arguments to pass to the driver.
    #[prost(string, repeated, tag = "1")]
    pub args: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// JAR file URIs to add to CLASSPATH of the Yandex Data Processing driver and each task.
    #[prost(string, repeated, tag = "2")]
    pub jar_file_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// URIs of resource files to be copied to the working directory of Yandex Data Processing drivers
    /// and distributed Hadoop tasks.
    #[prost(string, repeated, tag = "3")]
    pub file_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// URIs of archives to be extracted to the working directory of Yandex Data Processing drivers and tasks.
    #[prost(string, repeated, tag = "4")]
    pub archive_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Property names and values, used to configure Yandex Data Processing and PySpark.
    #[prost(map = "string, string", tag = "5")]
    pub properties: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// URI of the file with the driver code. Must be a .py file.
    #[prost(string, tag = "6")]
    pub main_python_file_uri: ::prost::alloc::string::String,
    /// URIs of Python files to pass to the PySpark framework.
    #[prost(string, repeated, tag = "7")]
    pub python_file_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// List of maven coordinates of jars to include on the driver and executor classpaths.
    #[prost(string, repeated, tag = "8")]
    pub packages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// List of additional remote repositories to search for the maven coordinates given with --packages.
    #[prost(string, repeated, tag = "9")]
    pub repositories: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// List of groupId:artifactId, to exclude while resolving the dependencies provided in --packages to avoid dependency conflicts.
    #[prost(string, repeated, tag = "10")]
    pub exclude_packages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryList {
    /// List of Hive queries.
    #[prost(string, repeated, tag = "1")]
    pub queries: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HiveJob {
    /// Property names and values, used to configure Yandex Data Processing and Hive.
    #[prost(map = "string, string", tag = "1")]
    pub properties: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Flag indicating whether a job should continue to run if a query fails.
    #[prost(bool, tag = "2")]
    pub continue_on_failure: bool,
    /// Query variables and their values.
    #[prost(map = "string, string", tag = "3")]
    pub script_variables: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// JAR file URIs to add to CLASSPATH of the Hive driver and each task.
    #[prost(string, repeated, tag = "4")]
    pub jar_file_uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(oneof = "hive_job::QueryType", tags = "5, 6")]
    pub query_type: ::core::option::Option<hive_job::QueryType>,
}
/// Nested message and enum types in `HiveJob`.
pub mod hive_job {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum QueryType {
        /// URI of the script with all the necessary Hive queries.
        #[prost(string, tag = "5")]
        QueryFileUri(::prost::alloc::string::String),
        /// List of Hive queries to be used in the job.
        #[prost(message, tag = "6")]
        QueryList(super::QueryList),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetJobRequest {
    /// ID of the cluster to request a job from.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the job to return.
    ///
    /// To get a job ID make a \[JobService.List\] request.
    #[prost(string, tag = "2")]
    pub job_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListJobsRequest {
    /// ID of the cluster to list jobs for.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\], the service returns a \[ListJobsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `page_token` to the
    /// \[ListJobsResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters jobs listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently you can use filtering only on \[Job.name\] field.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// Example of a filter: `name=my-job`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListJobsResponse {
    /// List of jobs for the specified cluster.
    #[prost(message, repeated, tag = "1")]
    pub jobs: ::prost::alloc::vec::Vec<Job>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListJobsRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListJobsRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateJobRequest {
    /// ID of the cluster to create a job for.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the job.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Specification for the job.
    #[prost(oneof = "create_job_request::JobSpec", tags = "3, 4, 5, 6")]
    pub job_spec: ::core::option::Option<create_job_request::JobSpec>,
}
/// Nested message and enum types in `CreateJobRequest`.
pub mod create_job_request {
    /// Specification for the job.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum JobSpec {
        /// Specification for a MapReduce job.
        #[prost(message, tag = "3")]
        MapreduceJob(super::MapreduceJob),
        /// Specification for a Spark job.
        #[prost(message, tag = "4")]
        SparkJob(super::SparkJob),
        /// Specification for a PySpark job.
        #[prost(message, tag = "5")]
        PysparkJob(super::PysparkJob),
        /// Specification for a Hive job.
        #[prost(message, tag = "6")]
        HiveJob(super::HiveJob),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateJobMetadata {
    /// ID of the cluster that the job is being created for.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the job being created.
    #[prost(string, tag = "2")]
    pub job_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CancelJobRequest {
    /// Required. ID of the Yandex Data Processing cluster.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Required. ID of the Yandex Data Processing job to cancel.
    #[prost(string, tag = "2")]
    pub job_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListJobLogRequest {
    /// ID of the cluster that the job is being created for.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the job being created.
    #[prost(string, tag = "2")]
    pub job_id: ::prost::alloc::string::String,
    /// The maximum bytes of job log per response to return. If the number of available
    /// bytes is larger than \[page_size\], the service returns a \[ListJobLogResponse.next_page_token\]
    /// that can be used to get the next page of output in subsequent list requests.
    /// Default value: 1048576.
    #[prost(int64, tag = "3")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `page_token` to the
    /// \[ListJobLogResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListJobLogResponse {
    /// Requested part of Yandex Data Processing Job log.
    #[prost(string, tag = "1")]
    pub content: ::prost::alloc::string::String,
    /// This token allows you to get the next page of results for ListLog requests,
    /// if the number of results is larger than `page_size` specified in the request.
    /// To get the next page, specify the value of `next_page_token` as a value for
    /// the `page_token` parameter in the next ListLog request. Subsequent ListLog
    /// requests will have their own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod job_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing Yandex Data Processing jobs.
    #[derive(Debug, Clone)]
    pub struct JobServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl JobServiceClient<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> JobServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> JobServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            JobServiceClient::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
        }
        /// Retrieves a list of jobs for a cluster.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListJobsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListJobsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.JobService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.dataproc.v1.JobService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Creates a job for a cluster.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateJobRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.JobService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.dataproc.v1.JobService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified job.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetJobRequest>,
        ) -> std::result::Result<tonic::Response<super::Job>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.JobService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.dataproc.v1.JobService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Returns a log for specified job.
        pub async fn list_log(
            &mut self,
            request: impl tonic::IntoRequest<super::ListJobLogRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListJobLogResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.JobService/ListLog",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.dataproc.v1.JobService", "ListLog"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Cancels the specified Yandex Data Processing job.
        pub async fn cancel(
            &mut self,
            request: impl tonic::IntoRequest<super::CancelJobRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.JobService/Cancel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.dataproc.v1.JobService", "Cancel"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A ResourcePreset resource for describing hardware configuration presets.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResourcePreset {
    /// ID of the ResourcePreset resource.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// IDs of availability zones where the resource preset is available.
    #[prost(string, repeated, tag = "2")]
    pub zone_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Number of CPU cores for a Yandex Data Processing host created with the preset.
    #[prost(int64, tag = "3")]
    pub cores: i64,
    /// RAM volume for a Yandex Data Processing host created with the preset, in bytes.
    #[prost(int64, tag = "4")]
    pub memory: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetResourcePresetRequest {
    /// Required. ID of the resource preset to return.
    /// To get the resource preset ID, use a \[ResourcePresetService.List\] request.
    #[prost(string, tag = "1")]
    pub resource_preset_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListResourcePresetsRequest {
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\], the service returns a \[ListResourcePresetsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "1")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the \[ListResourcePresetsResponse.next_page_token\]
    /// returned by a previous list request.
    #[prost(string, tag = "2")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListResourcePresetsResponse {
    /// List of ResourcePreset resources.
    #[prost(message, repeated, tag = "1")]
    pub resource_presets: ::prost::alloc::vec::Vec<ResourcePreset>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListResourcePresetsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListResourcePresetsRequest.page_token\] parameter in the next list request. Each subsequent
    /// list request will have its own \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod resource_preset_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing ResourcePreset resources.
    #[derive(Debug, Clone)]
    pub struct ResourcePresetServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ResourcePresetServiceClient<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> ResourcePresetServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> ResourcePresetServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            ResourcePresetServiceClient::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
        }
        /// Returns the specified ResourcePreset resource.
        ///
        /// To get the list of available ResourcePreset resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetResourcePresetRequest>,
        ) -> std::result::Result<tonic::Response<super::ResourcePreset>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.ResourcePresetService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.dataproc.v1.ResourcePresetService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of available ResourcePreset resources.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListResourcePresetsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListResourcePresetsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.ResourcePresetService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.dataproc.v1.ResourcePresetService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSubclusterRequest {
    /// ID of the Yandex Data Processing cluster that the subcluster belongs to.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the subcluster to return.
    ///
    /// To get a subcluster ID make a \[SubclusterService.List\] request.
    #[prost(string, tag = "2")]
    pub subcluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSubclustersRequest {
    /// ID of the Yandex Data Processing cluster to list subclusters in.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\], the service returns a \[ListSubclustersResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set `page_token` to the
    /// \[ListSubclustersResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters subclusters listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently you can use filtering only on \[Subcluster.name\] field.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    /// Example of a filter: `name=dataproc123_subcluster456`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSubclustersResponse {
    /// List of subclusters in the specified cluster.
    #[prost(message, repeated, tag = "1")]
    pub subclusters: ::prost::alloc::vec::Vec<Subcluster>,
    /// Token for getting the next page of the list. If the number of results is greater than
    /// the specified \[ListSubclustersRequest.page_size\], use `next_page_token` as the value
    /// for the \[ListSubclustersRequest.page_token\] parameter in the next list request.
    ///
    /// Each subsequent page will have its own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSubclusterRequest {
    /// ID of the Yandex Data Processing cluster to create a subcluster in.
    ///
    /// To get a cluster ID, make a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the subcluster. The name must be unique within the cluster. The name can't be
    /// changed when the subcluster is created.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Role that is fulfilled by hosts of the subcluster.
    #[prost(enumeration = "Role", tag = "3")]
    pub role: i32,
    /// Resources allocated for each host in the subcluster.
    #[prost(message, optional, tag = "4")]
    pub resources: ::core::option::Option<Resources>,
    /// ID of the VPC subnet used for hosts in the subcluster.
    #[prost(string, tag = "5")]
    pub subnet_id: ::prost::alloc::string::String,
    /// Number of hosts in the subcluster.
    #[prost(int64, tag = "6")]
    pub hosts_count: i64,
    /// Configuration for instance group based subclusters
    #[prost(message, optional, tag = "7")]
    pub autoscaling_config: ::core::option::Option<AutoscalingConfig>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSubclusterMetadata {
    /// ID of the cluster that the subcluster is being added to.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the subcluster that is being created.
    #[prost(string, tag = "2")]
    pub subcluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSubclusterRequest {
    /// ID of the cluster to update a subcluster in.
    ///
    /// To get a cluster ID, make a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the subcluster to update.
    ///
    /// To get a subcluster ID, make a \[SubclusterService.List\] request.
    #[prost(string, tag = "2")]
    pub subcluster_id: ::prost::alloc::string::String,
    /// Field mask that specifies which attributes of the subcluster should be updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New configuration of resources that should be allocated for each host in the subcluster.
    #[prost(message, optional, tag = "4")]
    pub resources: ::core::option::Option<Resources>,
    /// New name for the subcluster. The name must be unique within the cluster.
    #[prost(string, tag = "5")]
    pub name: ::prost::alloc::string::String,
    /// New number of hosts in the subcluster.
    #[prost(int64, tag = "6")]
    pub hosts_count: i64,
    /// Timeout to gracefully decommission nodes. In seconds. Default value: 0
    #[prost(int64, tag = "7")]
    pub decommission_timeout: i64,
    /// Configuration for instance group based subclusters
    #[prost(message, optional, tag = "8")]
    pub autoscaling_config: ::core::option::Option<AutoscalingConfig>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateSubclusterMetadata {
    /// ID of the cluster whose subcluster is being updated.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the subcluster that is being updated.
    #[prost(string, tag = "2")]
    pub subcluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSubclusterRequest {
    /// ID of the cluster to remove a subcluster from.
    ///
    /// To get a cluster ID, make a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the subcluster to delete.
    #[prost(string, tag = "2")]
    pub subcluster_id: ::prost::alloc::string::String,
    /// Timeout to gracefully decommission nodes. In seconds. Default value: 0
    #[prost(int64, tag = "3")]
    pub decommission_timeout: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSubclusterMetadata {
    /// ID of the cluster whose subcluster is being deleted.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the subcluster that is being deleted.
    #[prost(string, tag = "2")]
    pub subcluster_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod subcluster_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing Yandex Data Processing subclusters.
    #[derive(Debug, Clone)]
    pub struct SubclusterServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl SubclusterServiceClient<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> SubclusterServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> SubclusterServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            SubclusterServiceClient::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
        }
        /// Returns the specified subcluster.
        ///
        /// To get the list of all available subclusters, make a [SubclusterService.List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSubclusterRequest>,
        ) -> std::result::Result<tonic::Response<super::Subcluster>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.SubclusterService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.dataproc.v1.SubclusterService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves a list of subclusters in the specified cluster.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSubclustersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListSubclustersResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.SubclusterService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.dataproc.v1.SubclusterService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a subcluster in the specified cluster.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateSubclusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.SubclusterService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.dataproc.v1.SubclusterService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified subcluster.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateSubclusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.SubclusterService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.dataproc.v1.SubclusterService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified subcluster.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteSubclusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.dataproc.v1.SubclusterService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.dataproc.v1.SubclusterService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}