yandex-cloud 2025.4.14

/// Description of a Redis backup. For more information, see
/// the Managed Service for Redis \[documentation\](/docs/managed-redis/concepts/backup).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Backup {
    /// ID of the backup.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the backup belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Creation timestamp in \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format
    /// (i.e. when the backup operation was completed).
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// ID of the Redis cluster that the backup was created for.
    #[prost(string, tag = "4")]
    pub source_cluster_id: ::prost::alloc::string::String,
    /// Start timestamp in \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format
    /// (i.e. when the backup operation was started).
    #[prost(message, optional, tag = "5")]
    pub started_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Shard names used as a source for backup.
    #[prost(string, repeated, tag = "6")]
    pub source_shard_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// How this backup was created (manual/automatic/etc...)
    #[prost(enumeration = "backup::BackupType", tag = "7")]
    pub r#type: i32,
}
/// Nested message and enum types in `Backup`.
pub mod backup {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum BackupType {
        Unspecified = 0,
        /// Backup created by automated daily schedule
        Automated = 1,
        /// Backup created by user request
        Manual = 2,
    }
    impl BackupType {
        /// 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 {
                BackupType::Unspecified => "BACKUP_TYPE_UNSPECIFIED",
                BackupType::Automated => "AUTOMATED",
                BackupType::Manual => "MANUAL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "BACKUP_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "AUTOMATED" => Some(Self::Automated),
                "MANUAL" => Some(Self::Manual),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetBackupRequest {
    /// ID of the Redis backup to return.
    /// To get the backup ID, use a \[ClusterService.ListBackups\] request.
    #[prost(string, tag = "1")]
    pub backup_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBackupsRequest {
    /// ID of the folder to list backups in.
    /// To get the folder ID, use 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 \[ListBackupsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the \[ListBackupsResponse.next_page_token\]
    /// returned by the 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 ListBackupsResponse {
    /// Requested list of backups.
    #[prost(message, repeated, tag = "1")]
    pub backups: ::prost::alloc::vec::Vec<Backup>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListBackupsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListBackupsRequest.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,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteBackupRequest {
    /// Required. ID of the backup to delete.
    #[prost(string, tag = "1")]
    pub backup_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteBackupMetadata {
    /// Required. ID of the deleting Redis backup.
    #[prost(string, tag = "1")]
    pub backup_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod backup_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 Redis backups.
    #[derive(Debug, Clone)]
    pub struct BackupServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl BackupServiceClient<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> BackupServiceClient<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,
        ) -> BackupServiceClient<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,
        {
            BackupServiceClient::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 Redis backup.
        ///
        /// To get the list of available Redis backups, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetBackupRequest>,
        ) -> std::result::Result<tonic::Response<super::Backup>, 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.mdb.redis.v1.BackupService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.BackupService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of Redis backups available for the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListBackupsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListBackupsResponse>,
            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.mdb.redis.v1.BackupService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.BackupService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the list of available backups for the specified Redis cluster.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteBackupRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.BackupService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.BackupService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A maintenance window settings.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MaintenanceWindow {
    /// The maintenance policy in effect.
    #[prost(oneof = "maintenance_window::Policy", tags = "1, 2")]
    pub policy: ::core::option::Option<maintenance_window::Policy>,
}
/// Nested message and enum types in `MaintenanceWindow`.
pub mod maintenance_window {
    /// The maintenance policy in effect.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Policy {
        /// Maintenance operation can be scheduled anytime.
        #[prost(message, tag = "1")]
        Anytime(super::AnytimeMaintenanceWindow),
        /// Maintenance operation can be scheduled on a weekly basis.
        #[prost(message, tag = "2")]
        WeeklyMaintenanceWindow(super::WeeklyMaintenanceWindow),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnytimeMaintenanceWindow {}
/// Weelky maintenance window settings.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WeeklyMaintenanceWindow {
    /// Day of the week (in `DDD` format).
    #[prost(enumeration = "weekly_maintenance_window::WeekDay", tag = "1")]
    pub day: i32,
    /// Hour of the day in UTC (in `HH` format).
    #[prost(int64, tag = "2")]
    pub hour: i64,
}
/// Nested message and enum types in `WeeklyMaintenanceWindow`.
pub mod weekly_maintenance_window {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum WeekDay {
        Unspecified = 0,
        Mon = 1,
        Tue = 2,
        Wed = 3,
        Thu = 4,
        Fri = 5,
        Sat = 6,
        Sun = 7,
    }
    impl WeekDay {
        /// 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 {
                WeekDay::Unspecified => "WEEK_DAY_UNSPECIFIED",
                WeekDay::Mon => "MON",
                WeekDay::Tue => "TUE",
                WeekDay::Wed => "WED",
                WeekDay::Thu => "THU",
                WeekDay::Fri => "FRI",
                WeekDay::Sat => "SAT",
                WeekDay::Sun => "SUN",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "WEEK_DAY_UNSPECIFIED" => Some(Self::Unspecified),
                "MON" => Some(Self::Mon),
                "TUE" => Some(Self::Tue),
                "WED" => Some(Self::Wed),
                "THU" => Some(Self::Thu),
                "FRI" => Some(Self::Fri),
                "SAT" => Some(Self::Sat),
                "SUN" => Some(Self::Sun),
                _ => None,
            }
        }
    }
}
/// A planned maintenance operation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MaintenanceOperation {
    /// Information about this maintenance operation.
    #[prost(string, tag = "1")]
    pub info: ::prost::alloc::string::String,
    /// Time until which this maintenance operation is delayed.
    #[prost(message, optional, tag = "2")]
    pub delayed_until: ::core::option::Option<::prost_types::Timestamp>,
}
/// Description of a Redis cluster. For more information, see
/// the Managed Service for Redis \[documentation\](/docs/managed-redis/concepts/).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Cluster {
    /// ID of the Redis cluster.
    /// This ID is assigned by MDB at creation time.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the Redis cluster belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Creation timestamp in \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the Redis cluster.
    /// The name is unique within the folder. 3-63 characters long.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the Redis cluster. 0-256 characters long.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the Redis cluster as `key:value` pairs.
    /// Maximum 64 per cluster.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Deployment environment of the Redis cluster.
    #[prost(enumeration = "cluster::Environment", tag = "7")]
    pub environment: i32,
    /// Description of monitoring systems relevant to the Redis cluster.
    #[prost(message, repeated, tag = "8")]
    pub monitoring: ::prost::alloc::vec::Vec<Monitoring>,
    /// Configuration of the Redis cluster.
    #[prost(message, optional, tag = "9")]
    pub config: ::core::option::Option<ClusterConfig>,
    #[prost(string, tag = "10")]
    pub network_id: ::prost::alloc::string::String,
    /// Aggregated cluster health.
    #[prost(enumeration = "cluster::Health", tag = "11")]
    pub health: i32,
    /// Cluster status.
    #[prost(enumeration = "cluster::Status", tag = "12")]
    pub status: i32,
    /// Redis cluster mode on/off.
    #[prost(bool, tag = "13")]
    pub sharded: bool,
    /// Maintenance window for the cluster.
    #[prost(message, optional, tag = "14")]
    pub maintenance_window: ::core::option::Option<MaintenanceWindow>,
    /// Planned maintenance operation to be started for the cluster within the nearest \[maintenance_window\].
    #[prost(message, optional, tag = "15")]
    pub planned_operation: ::core::option::Option<MaintenanceOperation>,
    /// User security groups
    #[prost(string, repeated, tag = "16")]
    pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// TLS port and functionality on\off
    #[prost(bool, tag = "17")]
    pub tls_enabled: bool,
    /// Deletion Protection inhibits deletion of the cluster
    #[prost(bool, tag = "18")]
    pub deletion_protection: bool,
    /// Persistence mode
    #[prost(enumeration = "cluster::PersistenceMode", tag = "19")]
    pub persistence_mode: i32,
    /// Enable FQDN instead of ip
    #[prost(bool, tag = "20")]
    pub announce_hostnames: bool,
    /// Allows to use ACL users to auth in sentinel
    #[prost(bool, tag = "21")]
    pub auth_sentinel: bool,
}
/// 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 Environment {
        Unspecified = 0,
        /// Stable environment with a conservative update policy:
        /// only hotfixes are applied during regular maintenance.
        Production = 1,
        /// Environment with more aggressive update policy: new versions
        /// are rolled out irrespective of backward compatibility.
        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,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Health {
        /// Cluster is in unknown state (we have no data)
        Unknown = 0,
        /// Cluster is alive and well (all hosts are alive)
        Alive = 1,
        /// Cluster is inoperable (it cannot perform any of its essential functions)
        Dead = 2,
        /// Cluster 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,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        /// Cluster status is unknown
        Unknown = 0,
        /// Cluster is being created
        Creating = 1,
        /// Cluster is running
        Running = 2,
        /// Cluster failed
        Error = 3,
        /// Cluster is being updated.
        Updating = 4,
        /// Cluster is stopping.
        Stopping = 5,
        /// Cluster stopped.
        Stopped = 6,
        /// Cluster is starting.
        Starting = 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::Unknown => "STATUS_UNKNOWN",
                Status::Creating => "CREATING",
                Status::Running => "RUNNING",
                Status::Error => "ERROR",
                Status::Updating => "UPDATING",
                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),
                "UPDATING" => Some(Self::Updating),
                "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 PersistenceMode {
        /// cluster persistence mode on
        On = 0,
        /// cluster persistence mode off
        Off = 1,
        /// cluster persistence on replicas only
        OnReplicas = 2,
    }
    impl PersistenceMode {
        /// 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 {
                PersistenceMode::On => "ON",
                PersistenceMode::Off => "OFF",
                PersistenceMode::OnReplicas => "ON_REPLICAS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ON" => Some(Self::On),
                "OFF" => Some(Self::Off),
                "ON_REPLICAS" => Some(Self::OnReplicas),
                _ => None,
            }
        }
    }
}
#[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 charts for the Redis cluster.
    #[prost(string, tag = "3")]
    pub link: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClusterConfig {
    /// Version of Redis server software.
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    /// Resources allocated to Redis hosts.
    #[prost(message, optional, tag = "3")]
    pub resources: ::core::option::Option<Resources>,
    /// Time to start the daily backup, in the UTC timezone.
    #[prost(message, optional, tag = "4")]
    pub backup_window_start: ::core::option::Option<
        super::super::super::super::super::google::r#type::TimeOfDay,
    >,
    /// Access policy to DB
    #[prost(message, optional, tag = "5")]
    pub access: ::core::option::Option<Access>,
    /// Unified configuration of a Redis cluster.
    #[prost(message, optional, tag = "9")]
    pub redis: ::core::option::Option<config::RedisConfigSet>,
    /// Disk size autoscaling settings
    #[prost(message, optional, tag = "10")]
    pub disk_size_autoscaling: ::core::option::Option<DiskSizeAutoscaling>,
    /// Retain period of automatically created backup in days
    #[prost(message, optional, tag = "13")]
    pub backup_retain_period_days: ::core::option::Option<i64>,
    /// Configuration for Redis servers in the cluster.
    #[prost(oneof = "cluster_config::RedisConfig", tags = "2, 6, 7, 8")]
    pub redis_config: ::core::option::Option<cluster_config::RedisConfig>,
}
/// Nested message and enum types in `ClusterConfig`.
pub mod cluster_config {
    /// Configuration for Redis servers in the cluster.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum RedisConfig {
        /// Configuration of a Redis 5.0 server.
        #[prost(message, tag = "2")]
        RedisConfig50(super::config::RedisConfigSet50),
        /// Configuration of a Redis 6.0 server.
        #[prost(message, tag = "6")]
        RedisConfig60(super::config::RedisConfigSet60),
        /// Configuration of a Redis 6.2 server.
        #[prost(message, tag = "7")]
        RedisConfig62(super::config::RedisConfigSet62),
        /// Configuration of a Redis 7.0 server.
        #[prost(message, tag = "8")]
        RedisConfig70(super::config::RedisConfigSet70),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Shard {
    /// Name of the Redis shard. The shard name is assigned by user at creation time, and cannot be changed.
    /// 1-63 characters long.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// ID of the Redis cluster the shard belongs to. The ID is assigned by MDB at creation time.
    #[prost(string, tag = "2")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Host {
    /// Name of the Redis host. The host name is assigned by MDB at creation time, and cannot be changed.
    /// 1-63 characters long.
    ///
    /// The name is unique across all MDB 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 Redis cluster. The ID is assigned by MDB at creation time.
    #[prost(string, tag = "2")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the availability zone where the Redis host resides.
    #[prost(string, tag = "3")]
    pub zone_id: ::prost::alloc::string::String,
    /// ID of the subnet that the host belongs to.
    #[prost(string, tag = "4")]
    pub subnet_id: ::prost::alloc::string::String,
    /// Resources allocated to the Redis host.
    #[prost(message, optional, tag = "5")]
    pub resources: ::core::option::Option<Resources>,
    /// Role of the host in the cluster. If the field has default value, it is not returned in the response.
    #[prost(enumeration = "host::Role", tag = "6")]
    pub role: i32,
    /// Aggregated health of the host. If the field has default value, it is not returned in the response.
    #[prost(enumeration = "host::Health", tag = "7")]
    pub health: i32,
    /// Services provided by the host.
    #[prost(message, repeated, tag = "8")]
    pub services: ::prost::alloc::vec::Vec<Service>,
    #[prost(string, tag = "9")]
    pub shard_name: ::prost::alloc::string::String,
    /// A replica with a low priority number is considered better for promotion.
    /// A replica with priority of 0 will never be selected by Redis Sentinel for promotion.
    /// Works only for non-sharded clusters. Default value is 100.
    #[prost(message, optional, tag = "10")]
    pub replica_priority: ::core::option::Option<i64>,
    /// Flag showing public IP assignment status to this host.
    #[prost(bool, tag = "11")]
    pub assign_public_ip: bool,
}
/// Nested message and enum types in `Host`.
pub mod host {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Role {
        /// Role of the host in the cluster is unknown. Default value.
        Unknown = 0,
        /// Host is the master Redis server in the cluster.
        Master = 1,
        /// Host is a replica (standby) Redis server in the cluster.
        Replica = 2,
    }
    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::Unknown => "ROLE_UNKNOWN",
                Role::Master => "MASTER",
                Role::Replica => "REPLICA",
            }
        }
        /// 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_UNKNOWN" => Some(Self::Unknown),
                "MASTER" => Some(Self::Master),
                "REPLICA" => Some(Self::Replica),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Health {
        /// Health of the host is unknown. Default value.
        Unknown = 0,
        /// The host is performing all its functions normally.
        Alive = 1,
        /// The host is inoperable, and cannot perform any of its essential functions.
        Dead = 2,
        /// The host is degraded, and can perform only 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,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Service {
    /// Type of the service provided by the host. If the field has default value, it is not returned in the response.
    #[prost(enumeration = "service::Type", tag = "1")]
    pub r#type: i32,
    /// Aggregated health of the service. If the field has default value, it is not returned in the response.
    #[prost(enumeration = "service::Health", tag = "2")]
    pub health: i32,
}
/// Nested message and enum types in `Service`.
pub mod service {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        /// Service type of the host is unspecified. Default value.
        Unspecified = 0,
        /// The host is a Redis server.
        Redis = 1,
        /// The host provides a Sentinel-only service (a quorum node).
        Arbiter = 2,
        /// The host is a Redis Cluster node.
        RedisCluster = 3,
    }
    impl Type {
        /// 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 {
                Type::Unspecified => "TYPE_UNSPECIFIED",
                Type::Redis => "REDIS",
                Type::Arbiter => "ARBITER",
                Type::RedisCluster => "REDIS_CLUSTER",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "REDIS" => Some(Self::Redis),
                "ARBITER" => Some(Self::Arbiter),
                "REDIS_CLUSTER" => Some(Self::RedisCluster),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Health {
        /// Health of the server is unknown. Default value.
        Unknown = 0,
        /// The server is working normally.
        Alive = 1,
        /// The server is dead or unresponsive.
        Dead = 2,
    }
    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",
            }
        }
        /// 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),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Resources {
    /// ID of the preset for computational resources available to a host (CPU, memory etc.).
    /// All available presets are listed in the \[documentation\](/docs/managed-redis/concepts/instance-types).
    #[prost(string, tag = "1")]
    pub resource_preset_id: ::prost::alloc::string::String,
    /// Volume of the storage available to a host, in bytes.
    #[prost(int64, tag = "2")]
    pub disk_size: i64,
    /// Type of the storage environment for the host.
    /// Possible values:
    /// * network-ssd - network SSD drive,
    /// * local-ssd - local SSD storage.
    #[prost(string, tag = "3")]
    pub disk_type_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Access {
    /// Allow access for DataLens
    #[prost(bool, tag = "1")]
    pub data_lens: bool,
    /// Allow access for Web SQL.
    #[prost(bool, tag = "2")]
    pub web_sql: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DiskSizeAutoscaling {
    /// Amount of used storage for automatic disk scaling in the maintenance window, 0 means disabled, in percent.
    #[prost(message, optional, tag = "1")]
    pub planned_usage_threshold: ::core::option::Option<i64>,
    /// Amount of used storage for immediately  automatic disk scaling, 0 means disabled, in percent.
    #[prost(message, optional, tag = "2")]
    pub emergency_usage_threshold: ::core::option::Option<i64>,
    /// Limit on how large the storage for database instances can automatically grow, in bytes.
    #[prost(message, optional, tag = "3")]
    pub disk_size_limit: ::core::option::Option<i64>,
}
/// A Redis User resource. For more information, see the
/// [Developer's Guide](/docs/managed-redis/concepts).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct User {
    /// Name of the Redis user.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// ID of the Redis cluster the user belongs to.
    #[prost(string, tag = "2")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Set of permissions to grant to the user.
    #[prost(message, optional, tag = "3")]
    pub permissions: ::core::option::Option<Permissions>,
    /// Is redis user enabled
    #[prost(bool, tag = "4")]
    pub enabled: bool,
    /// Raw ACL string inside of Redis
    #[prost(string, tag = "5")]
    pub acl_options: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Permissions {
    /// Keys patterns user has permission to.
    #[prost(message, optional, tag = "1")]
    pub patterns: ::core::option::Option<::prost::alloc::string::String>,
    /// Channel patterns user has permissions to.
    #[prost(message, optional, tag = "2")]
    pub pub_sub_channels: ::core::option::Option<::prost::alloc::string::String>,
    /// Command categories user has permissions to.
    #[prost(message, optional, tag = "3")]
    pub categories: ::core::option::Option<::prost::alloc::string::String>,
    /// Commands user can execute.
    #[prost(message, optional, tag = "4")]
    pub commands: ::core::option::Option<::prost::alloc::string::String>,
    /// SanitizePayload parameter.
    #[prost(message, optional, tag = "5")]
    pub sanitize_payload: ::core::option::Option<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UserSpec {
    /// Name of the Redis user.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Password of the Redis user.
    #[prost(string, repeated, tag = "2")]
    pub passwords: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Set of permissions to grant to the user.
    #[prost(message, optional, tag = "3")]
    pub permissions: ::core::option::Option<Permissions>,
    /// Is Redis user enabled
    #[prost(message, optional, tag = "4")]
    pub enabled: ::core::option::Option<bool>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EnableShardingClusterMetadata {
    #[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 EnableShardingClusterRequest {
    /// Required. ID of the Redis cluster to return.
    #[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 GetClusterRequest {
    /// ID of the Redis cluster to return.
    /// To get the cluster ID use 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 Redis clusters in.
    /// To get the folder ID, use 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.
    #[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 the 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 only use filtering with the \[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]{,61}[a-z0-9\])?`.
    #[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 Redis clusters.
    #[prost(message, repeated, tag = "1")]
    pub clusters: ::prost::alloc::vec::Vec<Cluster>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListClustersRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListClustersRequest.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,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateClusterRequest {
    /// ID of the folder to create the Redis cluster in.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the Redis cluster. The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the Redis cluster.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the Redis cluster as `key:value` pairs. Maximum 64 per cluster.
    /// For example, "project": "mvp" or "source": "dictionary".
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Deployment environment of the Redis cluster.
    #[prost(enumeration = "cluster::Environment", tag = "5")]
    pub environment: i32,
    /// Configuration and resources for hosts that should be created for the Redis cluster.
    #[prost(message, optional, tag = "6")]
    pub config_spec: ::core::option::Option<ConfigSpec>,
    /// Individual configurations for hosts that should be created for the Redis cluster.
    #[prost(message, repeated, tag = "7")]
    pub host_specs: ::prost::alloc::vec::Vec<HostSpec>,
    /// ID of the network to create the cluster in.
    #[prost(string, tag = "10")]
    pub network_id: ::prost::alloc::string::String,
    /// Redis cluster mode on/off.
    #[prost(bool, tag = "11")]
    pub sharded: bool,
    /// User security groups
    #[prost(string, repeated, tag = "12")]
    pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// TLS port and functionality on\off
    #[prost(message, optional, tag = "13")]
    pub tls_enabled: ::core::option::Option<bool>,
    /// Deletion Protection inhibits deletion of the cluster
    #[prost(bool, tag = "14")]
    pub deletion_protection: bool,
    /// Persistence mode
    #[prost(enumeration = "cluster::PersistenceMode", tag = "15")]
    pub persistence_mode: i32,
    /// Enable FQDN instead of ip
    #[prost(bool, tag = "16")]
    pub announce_hostnames: bool,
    /// Window of maintenance operations.
    #[prost(message, optional, tag = "17")]
    pub maintenance_window: ::core::option::Option<MaintenanceWindow>,
    /// Descriptions of users to be created in the Redis cluster.
    #[prost(message, repeated, tag = "18")]
    pub user_specs: ::prost::alloc::vec::Vec<UserSpec>,
    /// Allows to use ACL users to auth in sentinel
    #[prost(bool, tag = "19")]
    pub auth_sentinel: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateClusterMetadata {
    /// ID of the Redis 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 Redis cluster to update.
    /// To get the Redis cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the Redis cluster should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New description of the Redis cluster.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the Redis cluster as `` key:value `` pairs. Maximum 64 per cluster.
    /// For example, "project": "mvp" or "source": "dictionary".
    ///
    /// The new set of labels will completely replace the old ones. To add a label, request the current
    /// set with the \[ClusterService.Get\] method, then send an \[ClusterService.Update\] request with the new label added to the set.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// New configuration and resources for hosts in the cluster.
    #[prost(message, optional, tag = "5")]
    pub config_spec: ::core::option::Option<ConfigSpec>,
    /// New name for the cluster.
    #[prost(string, tag = "6")]
    pub name: ::prost::alloc::string::String,
    /// New maintenance window settings for the cluster.
    #[prost(message, optional, tag = "7")]
    pub maintenance_window: ::core::option::Option<MaintenanceWindow>,
    /// User security groups
    #[prost(string, repeated, tag = "8")]
    pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Deletion Protection inhibits deletion of the cluster
    #[prost(bool, tag = "9")]
    pub deletion_protection: bool,
    /// Persistence mode
    #[prost(enumeration = "cluster::PersistenceMode", tag = "10")]
    pub persistence_mode: i32,
    /// ID of the network to move the cluster to.
    #[prost(string, tag = "11")]
    pub network_id: ::prost::alloc::string::String,
    /// Enable FQDN instead of ip
    #[prost(bool, tag = "12")]
    pub announce_hostnames: bool,
    /// Allows to use ACL users to auth in sentinel
    #[prost(bool, tag = "13")]
    pub auth_sentinel: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateClusterMetadata {
    /// ID of the Redis 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 Redis cluster to delete.
    /// To get the Redis cluster ID, use 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 DeleteClusterMetadata {
    /// ID of the Redis 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 Redis cluster to start.
    #[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 Redis 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 StopClusterRequest {
    /// ID of the Redis cluster to stop.
    #[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 StopClusterMetadata {
    /// ID of the Redis 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 MoveClusterRequest {
    /// ID of the Redis cluster to move.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the destination folder.
    #[prost(string, tag = "2")]
    pub destination_folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveClusterMetadata {
    /// ID of the Redis cluster being moved.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the source folder.
    #[prost(string, tag = "2")]
    pub source_folder_id: ::prost::alloc::string::String,
    /// ID of the destination folder.
    #[prost(string, tag = "3")]
    pub destination_folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateClusterHostsRequest {
    /// ID of the Redis cluster to update hosts in.
    /// To get the Redis cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// New configurations to apply to hosts.
    #[prost(message, repeated, tag = "2")]
    pub update_host_specs: ::prost::alloc::vec::Vec<UpdateHostSpec>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateClusterHostsMetadata {
    /// ID of the Redis cluster to update hosts in.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Names of hosts that are being updated.
    #[prost(string, repeated, tag = "2")]
    pub host_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BackupClusterRequest {
    /// ID of the Redis cluster to back up.
    /// To get the Redis cluster ID, use 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 BackupClusterMetadata {
    /// ID of the Redis cluster that is being backed up.
    #[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 RestoreClusterRequest {
    /// ID of the backup to create a cluster from.
    /// To get the backup ID, use a \[ClusterService.ListBackups\] request.
    #[prost(string, tag = "1")]
    pub backup_id: ::prost::alloc::string::String,
    /// Name of the new Redis cluster. The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the new Redis cluster.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the Redis cluster as `` key:value `` pairs. Maximum 64 per cluster.
    /// For example, "project": "mvp" or "source": "dictionary".
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Deployment environment of the new Redis cluster.
    #[prost(enumeration = "cluster::Environment", tag = "5")]
    pub environment: i32,
    /// Configuration for the Redis cluster to be created.
    #[prost(message, optional, tag = "6")]
    pub config_spec: ::core::option::Option<ConfigSpec>,
    /// Configurations for Redis hosts that should be created for
    /// the cluster that is being created from the backup.
    #[prost(message, repeated, tag = "7")]
    pub host_specs: ::prost::alloc::vec::Vec<HostSpec>,
    /// ID of the network to create the Redis cluster in.
    #[prost(string, tag = "8")]
    pub network_id: ::prost::alloc::string::String,
    /// ID of the folder to create the Redis cluster in.
    #[prost(string, tag = "9")]
    pub folder_id: ::prost::alloc::string::String,
    /// User security groups
    #[prost(string, repeated, tag = "10")]
    pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// TLS port and functionality on\off
    #[prost(message, optional, tag = "11")]
    pub tls_enabled: ::core::option::Option<bool>,
    /// Persistence mode
    #[prost(enumeration = "cluster::PersistenceMode", tag = "12")]
    pub persistence_mode: i32,
    /// Deletion Protection inhibits deletion of the cluster
    #[prost(bool, tag = "13")]
    pub deletion_protection: bool,
    /// Enable FQDN instead of ip
    #[prost(bool, tag = "14")]
    pub announce_hostnames: bool,
    /// Window of maintenance operations.
    #[prost(message, optional, tag = "15")]
    pub maintenance_window: ::core::option::Option<MaintenanceWindow>,
    /// Allows to use ACL users to auth in sentinel
    #[prost(bool, tag = "16")]
    pub auth_sentinel: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RestoreClusterMetadata {
    /// ID of the new Redis cluster that is being created from a backup.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the backup that is being used for creating a cluster.
    #[prost(string, tag = "2")]
    pub backup_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartClusterFailoverRequest {
    /// ID of the Redis cluster to start failover on.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// List of hostnames which should not be masters. Can be empty for sentinel clusters or can contain multiple hosts for sharded clusters.
    #[prost(string, repeated, tag = "2")]
    pub host_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartClusterFailoverMetadata {
    /// ID of the Redis cluster on which failover will be initiated.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// List of hostnames which should not be masters. Can be empty for sentinel clusters or can contain multiple hosts for sharded clusters.
    #[prost(string, repeated, tag = "2")]
    pub host_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RescheduleMaintenanceRequest {
    /// ID of the Redis cluster to reschedule the maintenance operation for.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// The type of reschedule request.
    #[prost(enumeration = "reschedule_maintenance_request::RescheduleType", tag = "2")]
    pub reschedule_type: i32,
    /// The time until which this maintenance operation should be delayed. The value should be ahead of the first time when the maintenance operation has been scheduled for no more than two weeks. The value can also point to the past moment of time if \[reschedule_type.IMMEDIATE\] reschedule type is chosen.
    #[prost(message, optional, tag = "3")]
    pub delayed_until: ::core::option::Option<::prost_types::Timestamp>,
}
/// Nested message and enum types in `RescheduleMaintenanceRequest`.
pub mod reschedule_maintenance_request {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RescheduleType {
        Unspecified = 0,
        /// Start the maintenance operation immediately.
        Immediate = 1,
        /// Start the maintenance operation within the next available maintenance window.
        NextAvailableWindow = 2,
        /// Start the maintenance operation at the specific time.
        SpecificTime = 3,
    }
    impl RescheduleType {
        /// 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 {
                RescheduleType::Unspecified => "RESCHEDULE_TYPE_UNSPECIFIED",
                RescheduleType::Immediate => "IMMEDIATE",
                RescheduleType::NextAvailableWindow => "NEXT_AVAILABLE_WINDOW",
                RescheduleType::SpecificTime => "SPECIFIC_TIME",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RESCHEDULE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "IMMEDIATE" => Some(Self::Immediate),
                "NEXT_AVAILABLE_WINDOW" => Some(Self::NextAvailableWindow),
                "SPECIFIC_TIME" => Some(Self::SpecificTime),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RescheduleMaintenanceMetadata {
    /// Required. ID of the Redis cluster.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Required. The time until which this maintenance operation is to be delayed.
    #[prost(message, optional, tag = "4")]
    pub delayed_until: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogRecord {
    /// Log record timestamp in \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format.
    #[prost(message, optional, tag = "1")]
    pub timestamp: ::core::option::Option<::prost_types::Timestamp>,
    /// Contents of the log record.
    #[prost(map = "string, string", tag = "2")]
    pub message: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterLogsRequest {
    /// ID of the Redis cluster to request logs for.
    /// To get the Redis cluster ID use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Columns from the logs table to request.
    /// If no columns are specified, entire log records are returned.
    #[prost(string, repeated, tag = "2")]
    pub column_filter: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(enumeration = "list_cluster_logs_request::ServiceType", tag = "3")]
    pub service_type: i32,
    /// Start timestamp for the logs request, in \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format.
    #[prost(message, optional, tag = "4")]
    pub from_time: ::core::option::Option<::prost_types::Timestamp>,
    /// End timestamp for the logs request, in \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format.
    #[prost(message, optional, tag = "5")]
    pub to_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\], the service returns a \[ListClusterLogsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "6")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the
    /// \[ListClusterLogsResponse.next_page_token\] returned by the previous list request.
    #[prost(string, tag = "7")]
    pub page_token: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ListClusterLogsRequest`.
pub mod list_cluster_logs_request {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ServiceType {
        Unspecified = 0,
        /// Logs of Redis activity.
        Redis = 1,
    }
    impl ServiceType {
        /// 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 {
                ServiceType::Unspecified => "SERVICE_TYPE_UNSPECIFIED",
                ServiceType::Redis => "REDIS",
            }
        }
        /// 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_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "REDIS" => Some(Self::Redis),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterLogsResponse {
    /// Requested log records.
    #[prost(message, repeated, tag = "1")]
    pub logs: ::prost::alloc::vec::Vec<LogRecord>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListClusterLogsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListClusterLogsRequest.page_token\] query parameter in the next list request.
    /// Each subsequent list request will have its own \[next_page_token\] to continue paging through the results.
    /// This value is interchangeable with `next_record_token` from StreamLogs method.
    #[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 StreamLogRecord {
    /// One of the requested log records.
    #[prost(message, optional, tag = "1")]
    pub record: ::core::option::Option<LogRecord>,
    /// This token allows you to continue streaming logs starting from the exact
    /// same record. To continue streaming, specify value of `next_record_token`
    /// as value for `record_token` parameter in the next StreamLogs request.
    /// This value is interchangeable with `next_page_token` from ListLogs method.
    #[prost(string, tag = "2")]
    pub next_record_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamClusterLogsRequest {
    /// Required. ID of the Redis cluster.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Columns from logs table to get in the response.
    #[prost(string, repeated, tag = "2")]
    pub column_filter: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(enumeration = "stream_cluster_logs_request::ServiceType", tag = "3")]
    pub service_type: i32,
    /// Start timestamp for the logs request.
    #[prost(message, optional, tag = "4")]
    pub from_time: ::core::option::Option<::prost_types::Timestamp>,
    /// End timestamp for the logs request.
    /// If this field is not set, all existing logs will be sent and then the new ones as
    /// they appear. In essence it has 'tail -f' semantics.
    #[prost(message, optional, tag = "5")]
    pub to_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Record token. Set `record_token` to the `next_record_token` returned by a previous StreamLogs
    /// request to start streaming from next log record.
    #[prost(string, tag = "6")]
    pub record_token: ::prost::alloc::string::String,
    /// A filter expression that filters resources listed in the response.
    /// The expression must specify:
    /// 1. The field name. Currently filtering can be applied to the \[LogRecord.logs.hostname\] 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\]`.
    /// Examples of a filter `message.hostname='node1.db.cloud.yandex.net'`.
    #[prost(string, tag = "7")]
    pub filter: ::prost::alloc::string::String,
}
/// Nested message and enum types in `StreamClusterLogsRequest`.
pub mod stream_cluster_logs_request {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ServiceType {
        Unspecified = 0,
        /// Logs of Redis activity.
        Redis = 1,
    }
    impl ServiceType {
        /// 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 {
                ServiceType::Unspecified => "SERVICE_TYPE_UNSPECIFIED",
                ServiceType::Redis => "REDIS",
            }
        }
        /// 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_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "REDIS" => Some(Self::Redis),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterOperationsRequest {
    /// ID of the Redis 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.
    #[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 the 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 Redis cluster.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::super::operation::Operation>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListClusterOperationsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListClusterOperationsRequest.page_token\] query 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,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterBackupsRequest {
    /// ID of the Redis cluster.
    /// To get the Redis cluster ID use 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 \[ListClusterBackupsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token.  To get the next page of results, set \[page_token\] to the \[ListClusterBackupsResponse.next_page_token\]
    /// returned by the 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 ListClusterBackupsResponse {
    /// List of Redis backups.
    #[prost(message, repeated, tag = "1")]
    pub backups: ::prost::alloc::vec::Vec<Backup>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListClusterBackupsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListClusterBackupsRequest.page_token\] query 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,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterHostsRequest {
    /// ID of the Redis cluster.
    /// To get the Redis cluster ID use 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.
    #[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 the 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 ListClusterHostsResponse {
    /// List of hosts for the cluster.
    #[prost(message, repeated, tag = "1")]
    pub hosts: ::prost::alloc::vec::Vec<Host>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListClusterHostsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListClusterHostsRequest.page_token\] query 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,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddClusterHostsRequest {
    /// ID of the Redis cluster to add hosts to.
    /// To get the Redis cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Configurations for Redis hosts that should be added to the cluster.
    #[prost(message, repeated, tag = "2")]
    pub host_specs: ::prost::alloc::vec::Vec<HostSpec>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddClusterHostsMetadata {
    /// ID of the Redis cluster to which the hosts are being added.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Names of hosts that are being added to the cluster.
    #[prost(string, repeated, tag = "2")]
    pub host_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteClusterHostsRequest {
    /// ID of the Redis cluster to remove hosts from.
    /// To get the Redis cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Names of hosts to delete.
    #[prost(string, repeated, tag = "2")]
    pub host_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteClusterHostsMetadata {
    /// ID of the Redis cluster to remove hosts from.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Names of hosts that are being deleted.
    #[prost(string, repeated, tag = "2")]
    pub host_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetClusterShardRequest {
    /// ID of the Redis cluster the shard belongs to.
    /// To get the cluster ID use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of Redis shard to return.
    /// To get the shard name use a \[ClusterService.ListShards\] request.
    #[prost(string, tag = "2")]
    pub shard_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterShardsRequest {
    /// ID of the Redis cluster to list shards in.
    /// To get the cluster ID use 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 \[ListClusterShardsResponse.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
    /// \[ListClusterShardsResponse.next_page_token\] returned by the 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 ListClusterShardsResponse {
    /// List of Redis shards.
    #[prost(message, repeated, tag = "1")]
    pub shards: ::prost::alloc::vec::Vec<Shard>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListClusterShardsRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListClusterShardsRequest.page_token\] query 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,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddClusterShardRequest {
    /// ID of the Redis cluster to create a shard in.
    /// To get the cluster ID use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the shard.
    /// The name must be unique within the cluster.
    #[prost(string, tag = "2")]
    pub shard_name: ::prost::alloc::string::String,
    /// Configurations for Redis hosts that should be created with the shard.
    /// Must contain at least one element.
    #[prost(message, repeated, tag = "4")]
    pub host_specs: ::prost::alloc::vec::Vec<HostSpec>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddClusterShardMetadata {
    /// ID of the Redis cluster that a shard is being added to.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the Redis shard that is being created.
    #[prost(string, tag = "2")]
    pub shard_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteClusterShardRequest {
    /// ID of the Redis cluster the shard belongs to.
    /// To get the cluster ID use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the Redis shard to delete.
    /// To get the shard name use a \[ClusterService.ListShards\] request.
    #[prost(string, tag = "2")]
    pub shard_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteClusterShardMetadata {
    /// ID of the Redis cluster the shard belongs to.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the Redis shard that is being deleted.
    #[prost(string, tag = "2")]
    pub shard_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RebalanceClusterRequest {
    /// ID of the Redis cluster to rebalance.
    /// To get the cluster ID use 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 RebalanceClusterMetadata {
    /// ID of the Redis cluster that is being rebalancing.
    #[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 UpdateHostSpec {
    /// Name of the host to update.
    /// To get the Redis host name, use a \[ClusterService.ListHosts\] request.
    #[prost(string, tag = "1")]
    pub host_name: ::prost::alloc::string::String,
    /// A replica with a low priority number is considered better for promotion.
    /// A replica with priority of 0 will never be selected by Redis Sentinel for promotion.
    /// Works only for non-sharded clusters. Default value is 100.
    #[prost(message, optional, tag = "2")]
    pub replica_priority: ::core::option::Option<i64>,
    /// Whether the host should get a public IP address on update.
    #[prost(bool, tag = "3")]
    pub assign_public_ip: bool,
    /// Field mask that specifies which fields of the Redis host should be updated.
    #[prost(message, optional, tag = "4")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HostSpec {
    /// ID of the availability zone where the host resides.
    /// To get a list of available zones, use the \[yandex.cloud.compute.v1.ZoneService.List\] request.
    #[prost(string, tag = "1")]
    pub zone_id: ::prost::alloc::string::String,
    /// ID of the subnet that the host should belong to. This subnet should be a part
    /// of the network that the cluster belongs to.
    /// The ID of the network is set in the field \[Cluster.network_id\].
    #[prost(string, tag = "2")]
    pub subnet_id: ::prost::alloc::string::String,
    /// ID of the Redis shard the host belongs to.
    /// To get the shard ID use a \[ClusterService.ListShards\] request.
    #[prost(string, tag = "3")]
    pub shard_name: ::prost::alloc::string::String,
    /// A replica with a low priority number is considered better for promotion.
    /// A replica with priority of 0 will never be selected by Redis Sentinel for promotion.
    /// Works only for non-sharded clusters. Default value is 100.
    #[prost(message, optional, tag = "4")]
    pub replica_priority: ::core::option::Option<i64>,
    /// Whether the host should get a public IP address on creation.
    ///
    /// Possible values:
    /// * false - don't assign a public IP to the host.
    /// * true - the host should have a public IP address.
    #[prost(bool, tag = "5")]
    pub assign_public_ip: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConfigSpec {
    /// Version of Redis used in the cluster.
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    /// Resources allocated to Redis hosts.
    #[prost(message, optional, tag = "3")]
    pub resources: ::core::option::Option<Resources>,
    /// Time to start the daily backup, in the UTC timezone.
    #[prost(message, optional, tag = "4")]
    pub backup_window_start: ::core::option::Option<
        super::super::super::super::super::google::r#type::TimeOfDay,
    >,
    /// Access policy to DB
    #[prost(message, optional, tag = "5")]
    pub access: ::core::option::Option<Access>,
    /// Unified configuration of a Redis cluster
    #[prost(message, optional, tag = "11")]
    pub redis: ::core::option::Option<config::RedisConfig>,
    /// Disk size autoscaling settings
    #[prost(message, optional, tag = "12")]
    pub disk_size_autoscaling: ::core::option::Option<DiskSizeAutoscaling>,
    /// Retain period of automatically created backup in days
    #[prost(message, optional, tag = "13")]
    pub backup_retain_period_days: ::core::option::Option<i64>,
    /// Configuration of a Redis cluster.
    #[prost(oneof = "config_spec::RedisSpec", tags = "2, 6, 7, 8")]
    pub redis_spec: ::core::option::Option<config_spec::RedisSpec>,
}
/// Nested message and enum types in `ConfigSpec`.
pub mod config_spec {
    /// Configuration of a Redis cluster.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum RedisSpec {
        #[prost(message, tag = "2")]
        RedisConfig50(super::config::RedisConfig50),
        #[prost(message, tag = "6")]
        RedisConfig60(super::config::RedisConfig60),
        #[prost(message, tag = "7")]
        RedisConfig62(super::config::RedisConfig62),
        #[prost(message, tag = "8")]
        RedisConfig70(super::config::RedisConfig70),
    }
}
/// 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 Redis 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 Redis cluster.
        ///
        /// To get the list of available Redis clusters, make a [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.mdb.redis.v1.ClusterService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.ClusterService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of Redis clusters that belong
        /// to 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.mdb.redis.v1.ClusterService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.ClusterService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a Redis 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::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.mdb.redis.v1.ClusterService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.ClusterService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified Redis cluster.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.ClusterService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified Redis cluster.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.ClusterService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Start the specified Redis cluster.
        pub async fn start(
            &mut self,
            request: impl tonic::IntoRequest<super::StartClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/Start",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.ClusterService", "Start"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Stop the specified Redis cluster.
        pub async fn stop(
            &mut self,
            request: impl tonic::IntoRequest<super::StopClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/Stop",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.ClusterService", "Stop"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Moves a Redis cluster to the specified folder.
        pub async fn r#move(
            &mut self,
            request: impl tonic::IntoRequest<super::MoveClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/Move",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.ClusterService", "Move"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a backup for the specified Redis cluster.
        pub async fn backup(
            &mut self,
            request: impl tonic::IntoRequest<super::BackupClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/Backup",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.ClusterService", "Backup"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new Redis cluster using the specified backup.
        pub async fn restore(
            &mut self,
            request: impl tonic::IntoRequest<super::RestoreClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/Restore",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "Restore",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Reschedules planned maintenance operation.
        pub async fn reschedule_maintenance(
            &mut self,
            request: impl tonic::IntoRequest<super::RescheduleMaintenanceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/RescheduleMaintenance",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "RescheduleMaintenance",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Start a manual failover on the specified Redis cluster.
        pub async fn start_failover(
            &mut self,
            request: impl tonic::IntoRequest<super::StartClusterFailoverRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/StartFailover",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "StartFailover",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves logs for the specified Redis cluster.
        pub async fn list_logs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListClusterLogsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListClusterLogsResponse>,
            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.mdb.redis.v1.ClusterService/ListLogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "ListLogs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Same as ListLogs but using server-side streaming. Also allows for 'tail -f' semantics.
        pub async fn stream_logs(
            &mut self,
            request: impl tonic::IntoRequest<super::StreamClusterLogsRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::StreamLogRecord>>,
            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.mdb.redis.v1.ClusterService/StreamLogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "StreamLogs",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// Retrieves the list of 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.mdb.redis.v1.ClusterService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of available backups for the specified Redis cluster.
        pub async fn list_backups(
            &mut self,
            request: impl tonic::IntoRequest<super::ListClusterBackupsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListClusterBackupsResponse>,
            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.mdb.redis.v1.ClusterService/ListBackups",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "ListBackups",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves a list of hosts for 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.mdb.redis.v1.ClusterService/ListHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "ListHosts",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates new hosts for a cluster.
        pub async fn add_hosts(
            &mut self,
            request: impl tonic::IntoRequest<super::AddClusterHostsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/AddHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "AddHosts",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified hosts for a cluster.
        pub async fn delete_hosts(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteClusterHostsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/DeleteHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "DeleteHosts",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified hosts.
        pub async fn update_hosts(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateClusterHostsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/UpdateHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "UpdateHosts",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified shard.
        pub async fn get_shard(
            &mut self,
            request: impl tonic::IntoRequest<super::GetClusterShardRequest>,
        ) -> std::result::Result<tonic::Response<super::Shard>, 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.mdb.redis.v1.ClusterService/GetShard",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "GetShard",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves a list of shards.
        pub async fn list_shards(
            &mut self,
            request: impl tonic::IntoRequest<super::ListClusterShardsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListClusterShardsResponse>,
            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.mdb.redis.v1.ClusterService/ListShards",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "ListShards",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new shard.
        pub async fn add_shard(
            &mut self,
            request: impl tonic::IntoRequest<super::AddClusterShardRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/AddShard",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "AddShard",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified shard.
        pub async fn delete_shard(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteClusterShardRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/DeleteShard",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "DeleteShard",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Rebalances the cluster. Evenly distributes all the hash slots between the shards.
        pub async fn rebalance(
            &mut self,
            request: impl tonic::IntoRequest<super::RebalanceClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/Rebalance",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "Rebalance",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Enable Sharding on non sharded cluster
        pub async fn enable_sharding(
            &mut self,
            request: impl tonic::IntoRequest<super::EnableShardingClusterRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.ClusterService/EnableSharding",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ClusterService",
                        "EnableSharding",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A resource preset that describes hardware configuration for a host.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResourcePreset {
    /// ID of the resource preset.
    #[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>,
    /// RAM volume for a Redis host created with the preset, in bytes.
    #[prost(int64, tag = "3")]
    pub memory: i64,
    /// Number of CPU cores for a Redis host created with the preset.
    #[prost(int64, tag = "4")]
    pub cores: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetResourcePresetRequest {
    /// 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 = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the \[ListResourcePresetsResponse.next_page_token\]
    /// returned by the 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 ListResourcePresetsResponse {
    /// List of resource presets.
    #[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 working with resource presets.
    #[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 resource preset.
        ///
        /// To get the list of available resource presets, 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.mdb.redis.v1.ResourcePresetService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ResourcePresetService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of available resource presets.
        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.mdb.redis.v1.ResourcePresetService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.redis.v1.ResourcePresetService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetUserRequest {
    /// ID of the Redis cluster the user belongs to.
    /// To get the cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the Redis User resource to return.
    /// To get the name of the user, use a \[UserService.List\] request.
    #[prost(string, tag = "2")]
    pub user_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListUsersRequest {
    /// ID of the cluster to list Redis users in.
    /// To get the cluster ID, use 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 \[ListUsersResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the
    /// \[ListUsersResponse.next_page_token\] returned by the 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 ListUsersResponse {
    /// List of Redis User resources.
    #[prost(message, repeated, tag = "1")]
    pub users: ::prost::alloc::vec::Vec<User>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListUsersRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListUsersRequest.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,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateUserRequest {
    /// ID of the Redis cluster to create a user in.
    /// To get the cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Properties of the user to be created.
    #[prost(message, optional, tag = "2")]
    pub user_spec: ::core::option::Option<UserSpec>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateUserMetadata {
    /// ID of the Redis cluster the user is being created in.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the user that is being created.
    #[prost(string, tag = "2")]
    pub user_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateUserRequest {
    /// ID of the Redis cluster the user belongs to.
    /// To get the cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the Redis user to be updated.
    #[prost(string, tag = "2")]
    pub user_name: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the Redis User resource should be updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New passwords the Redis user.
    #[prost(string, repeated, tag = "4")]
    pub passwords: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// New set of permissions to grant to the user.
    #[prost(message, optional, tag = "5")]
    pub permissions: ::core::option::Option<Permissions>,
    /// Is Redis user enabled
    #[prost(bool, tag = "6")]
    pub enabled: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateUserMetadata {
    /// ID of the Redis cluster the user belongs to.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the user that is being updated.
    #[prost(string, tag = "2")]
    pub user_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteUserRequest {
    /// ID of the Redis cluster the user belongs to.
    /// To get the cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the user to delete.
    /// To get the name of the user use a \[UserService.List\] request.
    #[prost(string, tag = "2")]
    pub user_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteUserMetadata {
    /// ID of the Redis cluster the user belongs to.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the user that is being deleted.
    #[prost(string, tag = "2")]
    pub user_name: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod user_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 Redis User resources.
    #[derive(Debug, Clone)]
    pub struct UserServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl UserServiceClient<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> UserServiceClient<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,
        ) -> UserServiceClient<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,
        {
            UserServiceClient::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 Redis User resource.
        ///
        /// To get the list of available Redis User resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetUserRequest>,
        ) -> std::result::Result<tonic::Response<super::User>, 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.mdb.redis.v1.UserService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.mdb.redis.v1.UserService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of Redis User resources in the specified cluster.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListUsersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListUsersResponse>,
            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.mdb.redis.v1.UserService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.UserService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a Redis user in the specified cluster.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateUserRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.UserService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.UserService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified Redis user.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateUserRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.UserService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.UserService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified Redis user.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteUserRequest>,
        ) -> std::result::Result<
            tonic::Response<super::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.mdb.redis.v1.UserService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.redis.v1.UserService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}