yandex-cloud 2025.4.14

/// Fields and structure of `RedisConfig` reflects Redis configuration file
/// parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RedisConfig {
    /// Redis key eviction policy for a dataset that reaches maximum memory,
    /// available to the host. Redis maxmemory setting depends on Managed
    /// Service for Redis [host class](/docs/managed-redis/concepts/instance-types).
    ///
    /// All policies are described in detail in [Redis documentation](<https://redis.io/topics/lru-cache>).
    #[prost(enumeration = "redis_config::MaxmemoryPolicy", tag = "1")]
    pub maxmemory_policy: i32,
    /// Time that Redis keeps the connection open while the client is idle.
    /// If no new command is sent during that time, the connection is closed.
    #[prost(message, optional, tag = "2")]
    pub timeout: ::core::option::Option<i64>,
    /// Authentication password.
    #[prost(string, tag = "3")]
    pub password: ::prost::alloc::string::String,
    /// Number of database buckets on a single redis-server process.
    #[prost(message, optional, tag = "4")]
    pub databases: ::core::option::Option<i64>,
    /// Threshold for logging slow requests to server in microseconds (log only slower than it).
    #[prost(message, optional, tag = "5")]
    pub slowlog_log_slower_than: ::core::option::Option<i64>,
    /// Max slow requests number to log.
    #[prost(message, optional, tag = "6")]
    pub slowlog_max_len: ::core::option::Option<i64>,
    /// String setting for pub\sub functionality.
    #[prost(string, tag = "7")]
    pub notify_keyspace_events: ::prost::alloc::string::String,
    /// Redis connection output buffers limits for pubsub operations.
    #[prost(message, optional, tag = "8")]
    pub client_output_buffer_limit_pubsub: ::core::option::Option<
        redis_config::ClientOutputBufferLimit,
    >,
    /// Redis connection output buffers limits for clients.
    #[prost(message, optional, tag = "9")]
    pub client_output_buffer_limit_normal: ::core::option::Option<
        redis_config::ClientOutputBufferLimit,
    >,
    /// Redis maxmemory percent
    #[prost(message, optional, tag = "10")]
    pub maxmemory_percent: ::core::option::Option<i64>,
    /// Maximum time in milliseconds for Lua scripts, 0 - disabled mechanism
    #[prost(message, optional, tag = "11")]
    pub lua_time_limit: ::core::option::Option<i64>,
    /// Replication backlog size as a percentage of flavor maxmemory
    #[prost(message, optional, tag = "12")]
    pub repl_backlog_size_percent: ::core::option::Option<i64>,
    /// Controls whether all hash slots must be covered by nodes
    #[prost(message, optional, tag = "13")]
    pub cluster_require_full_coverage: ::core::option::Option<bool>,
    /// Allows read operations when cluster is down
    #[prost(message, optional, tag = "14")]
    pub cluster_allow_reads_when_down: ::core::option::Option<bool>,
    /// Permits Pub/Sub shard operations when cluster is down
    #[prost(message, optional, tag = "15")]
    pub cluster_allow_pubsubshard_when_down: ::core::option::Option<bool>,
    /// The time, in minutes, that must elapse in order for the key counter to be divided by two (or decremented if it has a value less <= 10)
    #[prost(message, optional, tag = "16")]
    pub lfu_decay_time: ::core::option::Option<i64>,
    /// Determines how the frequency counter represents key hits.
    #[prost(message, optional, tag = "17")]
    pub lfu_log_factor: ::core::option::Option<i64>,
    /// Allows to turn before switchover in RDSync
    #[prost(message, optional, tag = "18")]
    pub turn_before_switchover: ::core::option::Option<bool>,
    /// Allows some data to be lost in favor of faster switchover/restart
    #[prost(message, optional, tag = "19")]
    pub allow_data_loss: ::core::option::Option<bool>,
    /// Use JIT for lua scripts and functions
    #[prost(message, optional, tag = "20")]
    pub use_luajit: ::core::option::Option<bool>,
    /// Allow redis to use io-threads
    #[prost(message, optional, tag = "21")]
    pub io_threads_allowed: ::core::option::Option<bool>,
    /// Controls max number of entries in zset before conversion from memory-efficient listpack to CPU-efficient hash table and skiplist
    #[prost(message, optional, tag = "22")]
    pub zset_max_listpack_entries: ::core::option::Option<i64>,
    /// AOF maximum size as a percentage of disk available
    #[prost(message, optional, tag = "23")]
    pub aof_max_size_percent: ::core::option::Option<i64>,
    /// Enable active (online) memory defragmentation
    #[prost(message, optional, tag = "24")]
    pub activedefrag: ::core::option::Option<bool>,
}
/// Nested message and enum types in `RedisConfig`.
pub mod redis_config {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ClientOutputBufferLimit {
        /// Total limit in bytes.
        #[prost(message, optional, tag = "1")]
        pub hard_limit: ::core::option::Option<i64>,
        /// Limit in bytes during certain time period.
        #[prost(message, optional, tag = "3")]
        pub soft_limit: ::core::option::Option<i64>,
        /// Seconds for soft limit.
        #[prost(message, optional, tag = "5")]
        pub soft_seconds: ::core::option::Option<i64>,
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum MaxmemoryPolicy {
        Unspecified = 0,
        /// Try to remove less recently used (LRU) keys with `expire set`.
        VolatileLru = 1,
        /// Remove less recently used (LRU) keys.
        AllkeysLru = 2,
        /// Try to remove least frequently used (LFU) keys with `expire set`.
        VolatileLfu = 3,
        /// Remove least frequently used (LFU) keys.
        AllkeysLfu = 4,
        /// Try to remove keys with `expire set` randomly.
        VolatileRandom = 5,
        /// Remove keys randomly.
        AllkeysRandom = 6,
        /// Try to remove less recently used (LRU) keys with `expire set`
        /// and shorter TTL first.
        VolatileTtl = 7,
        /// Return errors when memory limit was reached and commands could require
        /// more memory to be used.
        Noeviction = 8,
    }
    impl MaxmemoryPolicy {
        /// 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 {
                MaxmemoryPolicy::Unspecified => "MAXMEMORY_POLICY_UNSPECIFIED",
                MaxmemoryPolicy::VolatileLru => "VOLATILE_LRU",
                MaxmemoryPolicy::AllkeysLru => "ALLKEYS_LRU",
                MaxmemoryPolicy::VolatileLfu => "VOLATILE_LFU",
                MaxmemoryPolicy::AllkeysLfu => "ALLKEYS_LFU",
                MaxmemoryPolicy::VolatileRandom => "VOLATILE_RANDOM",
                MaxmemoryPolicy::AllkeysRandom => "ALLKEYS_RANDOM",
                MaxmemoryPolicy::VolatileTtl => "VOLATILE_TTL",
                MaxmemoryPolicy::Noeviction => "NOEVICTION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MAXMEMORY_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
                "VOLATILE_LRU" => Some(Self::VolatileLru),
                "ALLKEYS_LRU" => Some(Self::AllkeysLru),
                "VOLATILE_LFU" => Some(Self::VolatileLfu),
                "ALLKEYS_LFU" => Some(Self::AllkeysLfu),
                "VOLATILE_RANDOM" => Some(Self::VolatileRandom),
                "ALLKEYS_RANDOM" => Some(Self::AllkeysRandom),
                "VOLATILE_TTL" => Some(Self::VolatileTtl),
                "NOEVICTION" => Some(Self::Noeviction),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RedisConfigSet {
    /// Effective settings for a Redis cluster (a combination of settings
    /// defined in \[user_config\] and \[default_config\]).
    #[prost(message, optional, tag = "1")]
    pub effective_config: ::core::option::Option<RedisConfig>,
    /// User-defined settings for a Redis cluster.
    #[prost(message, optional, tag = "2")]
    pub user_config: ::core::option::Option<RedisConfig>,
    /// Default configuration for a Redis cluster.
    #[prost(message, optional, tag = "3")]
    pub default_config: ::core::option::Option<RedisConfig>,
}
/// Fields and structure of `RedisConfig` reflects Redis configuration file
/// parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RedisConfig50 {
    /// Redis key eviction policy for a dataset that reaches maximum memory,
    /// available to the host. Redis maxmemory setting depends on Managed
    /// Service for Redis [host class](/docs/managed-redis/concepts/instance-types).
    ///
    /// All policies are described in detail in [Redis documentation](<https://redis.io/topics/lru-cache>).
    #[prost(enumeration = "redis_config5_0::MaxmemoryPolicy", tag = "1")]
    pub maxmemory_policy: i32,
    /// Time that Redis keeps the connection open while the client is idle.
    /// If no new command is sent during that time, the connection is closed.
    #[prost(message, optional, tag = "2")]
    pub timeout: ::core::option::Option<i64>,
    /// Authentication password.
    #[prost(string, tag = "3")]
    pub password: ::prost::alloc::string::String,
    /// Number of database buckets on a single redis-server process.
    #[prost(message, optional, tag = "4")]
    pub databases: ::core::option::Option<i64>,
    /// Threshold for logging slow requests to server in microseconds (log only slower than it).
    #[prost(message, optional, tag = "5")]
    pub slowlog_log_slower_than: ::core::option::Option<i64>,
    /// Max slow requests number to log.
    #[prost(message, optional, tag = "6")]
    pub slowlog_max_len: ::core::option::Option<i64>,
    /// String setting for pub\sub functionality.
    #[prost(string, tag = "7")]
    pub notify_keyspace_events: ::prost::alloc::string::String,
    /// Redis connection output buffers limits for pubsub operations.
    #[prost(message, optional, tag = "8")]
    pub client_output_buffer_limit_pubsub: ::core::option::Option<
        redis_config5_0::ClientOutputBufferLimit,
    >,
    /// Redis connection output buffers limits for clients.
    #[prost(message, optional, tag = "9")]
    pub client_output_buffer_limit_normal: ::core::option::Option<
        redis_config5_0::ClientOutputBufferLimit,
    >,
}
/// Nested message and enum types in `RedisConfig5_0`.
pub mod redis_config5_0 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ClientOutputBufferLimit {
        /// Total limit in bytes.
        #[prost(message, optional, tag = "1")]
        pub hard_limit: ::core::option::Option<i64>,
        /// Limit in bytes during certain time period.
        #[prost(message, optional, tag = "3")]
        pub soft_limit: ::core::option::Option<i64>,
        /// Seconds for soft limit.
        #[prost(message, optional, tag = "5")]
        pub soft_seconds: ::core::option::Option<i64>,
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum MaxmemoryPolicy {
        Unspecified = 0,
        /// Try to remove less recently used (LRU) keys with `expire set`.
        VolatileLru = 1,
        /// Remove less recently used (LRU) keys.
        AllkeysLru = 2,
        /// Try to remove least frequently used (LFU) keys with `expire set`.
        VolatileLfu = 3,
        /// Remove least frequently used (LFU) keys.
        AllkeysLfu = 4,
        /// Try to remove keys with `expire set` randomly.
        VolatileRandom = 5,
        /// Remove keys randomly.
        AllkeysRandom = 6,
        /// Try to remove less recently used (LRU) keys with `expire set`
        /// and shorter TTL first.
        VolatileTtl = 7,
        /// Return errors when memory limit was reached and commands could require
        /// more memory to be used.
        Noeviction = 8,
    }
    impl MaxmemoryPolicy {
        /// 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 {
                MaxmemoryPolicy::Unspecified => "MAXMEMORY_POLICY_UNSPECIFIED",
                MaxmemoryPolicy::VolatileLru => "VOLATILE_LRU",
                MaxmemoryPolicy::AllkeysLru => "ALLKEYS_LRU",
                MaxmemoryPolicy::VolatileLfu => "VOLATILE_LFU",
                MaxmemoryPolicy::AllkeysLfu => "ALLKEYS_LFU",
                MaxmemoryPolicy::VolatileRandom => "VOLATILE_RANDOM",
                MaxmemoryPolicy::AllkeysRandom => "ALLKEYS_RANDOM",
                MaxmemoryPolicy::VolatileTtl => "VOLATILE_TTL",
                MaxmemoryPolicy::Noeviction => "NOEVICTION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MAXMEMORY_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
                "VOLATILE_LRU" => Some(Self::VolatileLru),
                "ALLKEYS_LRU" => Some(Self::AllkeysLru),
                "VOLATILE_LFU" => Some(Self::VolatileLfu),
                "ALLKEYS_LFU" => Some(Self::AllkeysLfu),
                "VOLATILE_RANDOM" => Some(Self::VolatileRandom),
                "ALLKEYS_RANDOM" => Some(Self::AllkeysRandom),
                "VOLATILE_TTL" => Some(Self::VolatileTtl),
                "NOEVICTION" => Some(Self::Noeviction),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RedisConfigSet50 {
    /// Effective settings for a Redis 5.0 cluster (a combination of settings
    /// defined in \[user_config\] and \[default_config\]).
    #[prost(message, optional, tag = "1")]
    pub effective_config: ::core::option::Option<RedisConfig50>,
    /// User-defined settings for a Redis 5.0 cluster.
    #[prost(message, optional, tag = "2")]
    pub user_config: ::core::option::Option<RedisConfig50>,
    /// Default configuration for a Redis 5.0 cluster.
    #[prost(message, optional, tag = "3")]
    pub default_config: ::core::option::Option<RedisConfig50>,
}
/// Fields and structure of `RedisConfig` reflects Redis configuration file
/// parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RedisConfig60 {
    /// Redis key eviction policy for a dataset that reaches maximum memory,
    /// available to the host. Redis maxmemory setting depends on Managed
    /// Service for Redis [host class](/docs/managed-redis/concepts/instance-types).
    ///
    /// All policies are described in detail in [Redis documentation](<https://redis.io/topics/lru-cache>).
    #[prost(enumeration = "redis_config6_0::MaxmemoryPolicy", tag = "1")]
    pub maxmemory_policy: i32,
    /// Time that Redis keeps the connection open while the client is idle.
    /// If no new command is sent during that time, the connection is closed.
    #[prost(message, optional, tag = "2")]
    pub timeout: ::core::option::Option<i64>,
    /// Authentication password.
    #[prost(string, tag = "3")]
    pub password: ::prost::alloc::string::String,
    /// Number of database buckets on a single redis-server process.
    #[prost(message, optional, tag = "4")]
    pub databases: ::core::option::Option<i64>,
    /// Threshold for logging slow requests to server in microseconds (log only slower than it).
    #[prost(message, optional, tag = "5")]
    pub slowlog_log_slower_than: ::core::option::Option<i64>,
    /// Max slow requests number to log.
    #[prost(message, optional, tag = "6")]
    pub slowlog_max_len: ::core::option::Option<i64>,
    /// String setting for pub\sub functionality.
    #[prost(string, tag = "7")]
    pub notify_keyspace_events: ::prost::alloc::string::String,
    /// Redis connection output buffers limits for pubsub operations.
    #[prost(message, optional, tag = "8")]
    pub client_output_buffer_limit_pubsub: ::core::option::Option<
        redis_config6_0::ClientOutputBufferLimit,
    >,
    /// Redis connection output buffers limits for clients.
    #[prost(message, optional, tag = "9")]
    pub client_output_buffer_limit_normal: ::core::option::Option<
        redis_config6_0::ClientOutputBufferLimit,
    >,
}
/// Nested message and enum types in `RedisConfig6_0`.
pub mod redis_config6_0 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ClientOutputBufferLimit {
        /// Total limit in bytes.
        #[prost(message, optional, tag = "1")]
        pub hard_limit: ::core::option::Option<i64>,
        /// Limit in bytes during certain time period.
        #[prost(message, optional, tag = "3")]
        pub soft_limit: ::core::option::Option<i64>,
        /// Seconds for soft limit.
        #[prost(message, optional, tag = "5")]
        pub soft_seconds: ::core::option::Option<i64>,
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum MaxmemoryPolicy {
        Unspecified = 0,
        /// Try to remove less recently used (LRU) keys with `expire set`.
        VolatileLru = 1,
        /// Remove less recently used (LRU) keys.
        AllkeysLru = 2,
        /// Try to remove least frequently used (LFU) keys with `expire set`.
        VolatileLfu = 3,
        /// Remove least frequently used (LFU) keys.
        AllkeysLfu = 4,
        /// Try to remove keys with `expire set` randomly.
        VolatileRandom = 5,
        /// Remove keys randomly.
        AllkeysRandom = 6,
        /// Try to remove less recently used (LRU) keys with `expire set`
        /// and shorter TTL first.
        VolatileTtl = 7,
        /// Return errors when memory limit was reached and commands could require
        /// more memory to be used.
        Noeviction = 8,
    }
    impl MaxmemoryPolicy {
        /// 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 {
                MaxmemoryPolicy::Unspecified => "MAXMEMORY_POLICY_UNSPECIFIED",
                MaxmemoryPolicy::VolatileLru => "VOLATILE_LRU",
                MaxmemoryPolicy::AllkeysLru => "ALLKEYS_LRU",
                MaxmemoryPolicy::VolatileLfu => "VOLATILE_LFU",
                MaxmemoryPolicy::AllkeysLfu => "ALLKEYS_LFU",
                MaxmemoryPolicy::VolatileRandom => "VOLATILE_RANDOM",
                MaxmemoryPolicy::AllkeysRandom => "ALLKEYS_RANDOM",
                MaxmemoryPolicy::VolatileTtl => "VOLATILE_TTL",
                MaxmemoryPolicy::Noeviction => "NOEVICTION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MAXMEMORY_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
                "VOLATILE_LRU" => Some(Self::VolatileLru),
                "ALLKEYS_LRU" => Some(Self::AllkeysLru),
                "VOLATILE_LFU" => Some(Self::VolatileLfu),
                "ALLKEYS_LFU" => Some(Self::AllkeysLfu),
                "VOLATILE_RANDOM" => Some(Self::VolatileRandom),
                "ALLKEYS_RANDOM" => Some(Self::AllkeysRandom),
                "VOLATILE_TTL" => Some(Self::VolatileTtl),
                "NOEVICTION" => Some(Self::Noeviction),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RedisConfigSet60 {
    /// Effective settings for a Redis 6.0 cluster (a combination of settings
    /// defined in \[user_config\] and \[default_config\]).
    #[prost(message, optional, tag = "1")]
    pub effective_config: ::core::option::Option<RedisConfig60>,
    /// User-defined settings for a Redis 6.0 cluster.
    #[prost(message, optional, tag = "2")]
    pub user_config: ::core::option::Option<RedisConfig60>,
    /// Default configuration for a Redis 6.0 cluster.
    #[prost(message, optional, tag = "3")]
    pub default_config: ::core::option::Option<RedisConfig60>,
}
/// Fields and structure of `RedisConfig` reflects Redis configuration file
/// parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RedisConfig62 {
    /// Redis key eviction policy for a dataset that reaches maximum memory,
    /// available to the host. Redis maxmemory setting depends on Managed
    /// Service for Redis [host class](/docs/managed-redis/concepts/instance-types).
    ///
    /// All policies are described in detail in [Redis documentation](<https://redis.io/topics/lru-cache>).
    #[prost(enumeration = "redis_config6_2::MaxmemoryPolicy", tag = "1")]
    pub maxmemory_policy: i32,
    /// Time that Redis keeps the connection open while the client is idle.
    /// If no new command is sent during that time, the connection is closed.
    #[prost(message, optional, tag = "2")]
    pub timeout: ::core::option::Option<i64>,
    /// Authentication password.
    #[prost(string, tag = "3")]
    pub password: ::prost::alloc::string::String,
    /// Number of database buckets on a single redis-server process.
    #[prost(message, optional, tag = "4")]
    pub databases: ::core::option::Option<i64>,
    /// Threshold for logging slow requests to server in microseconds (log only slower than it).
    #[prost(message, optional, tag = "5")]
    pub slowlog_log_slower_than: ::core::option::Option<i64>,
    /// Max slow requests number to log.
    #[prost(message, optional, tag = "6")]
    pub slowlog_max_len: ::core::option::Option<i64>,
    /// String setting for pub\sub functionality.
    #[prost(string, tag = "7")]
    pub notify_keyspace_events: ::prost::alloc::string::String,
    /// Redis connection output buffers limits for pubsub operations.
    #[prost(message, optional, tag = "8")]
    pub client_output_buffer_limit_pubsub: ::core::option::Option<
        redis_config6_2::ClientOutputBufferLimit,
    >,
    /// Redis connection output buffers limits for clients.
    #[prost(message, optional, tag = "9")]
    pub client_output_buffer_limit_normal: ::core::option::Option<
        redis_config6_2::ClientOutputBufferLimit,
    >,
    /// Redis maxmemory percent
    #[prost(message, optional, tag = "10")]
    pub maxmemory_percent: ::core::option::Option<i64>,
}
/// Nested message and enum types in `RedisConfig6_2`.
pub mod redis_config6_2 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ClientOutputBufferLimit {
        /// Total limit in bytes.
        #[prost(message, optional, tag = "1")]
        pub hard_limit: ::core::option::Option<i64>,
        /// Limit in bytes during certain time period.
        #[prost(message, optional, tag = "3")]
        pub soft_limit: ::core::option::Option<i64>,
        /// Seconds for soft limit.
        #[prost(message, optional, tag = "5")]
        pub soft_seconds: ::core::option::Option<i64>,
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum MaxmemoryPolicy {
        Unspecified = 0,
        /// Try to remove less recently used (LRU) keys with `expire set`.
        VolatileLru = 1,
        /// Remove less recently used (LRU) keys.
        AllkeysLru = 2,
        /// Try to remove least frequently used (LFU) keys with `expire set`.
        VolatileLfu = 3,
        /// Remove least frequently used (LFU) keys.
        AllkeysLfu = 4,
        /// Try to remove keys with `expire set` randomly.
        VolatileRandom = 5,
        /// Remove keys randomly.
        AllkeysRandom = 6,
        /// Try to remove less recently used (LRU) keys with `expire set`
        /// and shorter TTL first.
        VolatileTtl = 7,
        /// Return errors when memory limit was reached and commands could require
        /// more memory to be used.
        Noeviction = 8,
    }
    impl MaxmemoryPolicy {
        /// 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 {
                MaxmemoryPolicy::Unspecified => "MAXMEMORY_POLICY_UNSPECIFIED",
                MaxmemoryPolicy::VolatileLru => "VOLATILE_LRU",
                MaxmemoryPolicy::AllkeysLru => "ALLKEYS_LRU",
                MaxmemoryPolicy::VolatileLfu => "VOLATILE_LFU",
                MaxmemoryPolicy::AllkeysLfu => "ALLKEYS_LFU",
                MaxmemoryPolicy::VolatileRandom => "VOLATILE_RANDOM",
                MaxmemoryPolicy::AllkeysRandom => "ALLKEYS_RANDOM",
                MaxmemoryPolicy::VolatileTtl => "VOLATILE_TTL",
                MaxmemoryPolicy::Noeviction => "NOEVICTION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MAXMEMORY_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
                "VOLATILE_LRU" => Some(Self::VolatileLru),
                "ALLKEYS_LRU" => Some(Self::AllkeysLru),
                "VOLATILE_LFU" => Some(Self::VolatileLfu),
                "ALLKEYS_LFU" => Some(Self::AllkeysLfu),
                "VOLATILE_RANDOM" => Some(Self::VolatileRandom),
                "ALLKEYS_RANDOM" => Some(Self::AllkeysRandom),
                "VOLATILE_TTL" => Some(Self::VolatileTtl),
                "NOEVICTION" => Some(Self::Noeviction),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RedisConfigSet62 {
    /// Effective settings for a Redis 6.2 cluster (a combination of settings
    /// defined in \[user_config\] and \[default_config\]).
    #[prost(message, optional, tag = "1")]
    pub effective_config: ::core::option::Option<RedisConfig62>,
    /// User-defined settings for a Redis 6.2 cluster.
    #[prost(message, optional, tag = "2")]
    pub user_config: ::core::option::Option<RedisConfig62>,
    /// Default configuration for a Redis 6.2 cluster.
    #[prost(message, optional, tag = "3")]
    pub default_config: ::core::option::Option<RedisConfig62>,
}
/// Fields and structure of `RedisConfig` reflects Redis configuration file
/// parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RedisConfig70 {
    /// Redis key eviction policy for a dataset that reaches maximum memory,
    /// available to the host. Redis maxmemory setting depends on Managed
    /// Service for Redis [host class](/docs/managed-redis/concepts/instance-types).
    ///
    /// All policies are described in detail in [Redis documentation](<https://redis.io/topics/lru-cache>).
    #[prost(enumeration = "redis_config7_0::MaxmemoryPolicy", tag = "1")]
    pub maxmemory_policy: i32,
    /// Time that Redis keeps the connection open while the client is idle.
    /// If no new command is sent during that time, the connection is closed.
    #[prost(message, optional, tag = "2")]
    pub timeout: ::core::option::Option<i64>,
    /// Authentication password.
    #[prost(string, tag = "3")]
    pub password: ::prost::alloc::string::String,
    /// Number of database buckets on a single redis-server process.
    #[prost(message, optional, tag = "4")]
    pub databases: ::core::option::Option<i64>,
    /// Threshold for logging slow requests to server in microseconds (log only slower than it).
    #[prost(message, optional, tag = "5")]
    pub slowlog_log_slower_than: ::core::option::Option<i64>,
    /// Max slow requests number to log.
    #[prost(message, optional, tag = "6")]
    pub slowlog_max_len: ::core::option::Option<i64>,
    /// String setting for pub\sub functionality.
    #[prost(string, tag = "7")]
    pub notify_keyspace_events: ::prost::alloc::string::String,
    /// Redis connection output buffers limits for pubsub operations.
    #[prost(message, optional, tag = "8")]
    pub client_output_buffer_limit_pubsub: ::core::option::Option<
        redis_config7_0::ClientOutputBufferLimit,
    >,
    /// Redis connection output buffers limits for clients.
    #[prost(message, optional, tag = "9")]
    pub client_output_buffer_limit_normal: ::core::option::Option<
        redis_config7_0::ClientOutputBufferLimit,
    >,
    /// Redis maxmemory percent
    #[prost(message, optional, tag = "10")]
    pub maxmemory_percent: ::core::option::Option<i64>,
}
/// Nested message and enum types in `RedisConfig7_0`.
pub mod redis_config7_0 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ClientOutputBufferLimit {
        /// Total limit in bytes.
        #[prost(message, optional, tag = "1")]
        pub hard_limit: ::core::option::Option<i64>,
        /// Limit in bytes during certain time period.
        #[prost(message, optional, tag = "3")]
        pub soft_limit: ::core::option::Option<i64>,
        /// Seconds for soft limit.
        #[prost(message, optional, tag = "5")]
        pub soft_seconds: ::core::option::Option<i64>,
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum MaxmemoryPolicy {
        Unspecified = 0,
        /// Try to remove less recently used (LRU) keys with `expire set`.
        VolatileLru = 1,
        /// Remove less recently used (LRU) keys.
        AllkeysLru = 2,
        /// Try to remove least frequently used (LFU) keys with `expire set`.
        VolatileLfu = 3,
        /// Remove least frequently used (LFU) keys.
        AllkeysLfu = 4,
        /// Try to remove keys with `expire set` randomly.
        VolatileRandom = 5,
        /// Remove keys randomly.
        AllkeysRandom = 6,
        /// Try to remove less recently used (LRU) keys with `expire set`
        /// and shorter TTL first.
        VolatileTtl = 7,
        /// Return errors when memory limit was reached and commands could require
        /// more memory to be used.
        Noeviction = 8,
    }
    impl MaxmemoryPolicy {
        /// 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 {
                MaxmemoryPolicy::Unspecified => "MAXMEMORY_POLICY_UNSPECIFIED",
                MaxmemoryPolicy::VolatileLru => "VOLATILE_LRU",
                MaxmemoryPolicy::AllkeysLru => "ALLKEYS_LRU",
                MaxmemoryPolicy::VolatileLfu => "VOLATILE_LFU",
                MaxmemoryPolicy::AllkeysLfu => "ALLKEYS_LFU",
                MaxmemoryPolicy::VolatileRandom => "VOLATILE_RANDOM",
                MaxmemoryPolicy::AllkeysRandom => "ALLKEYS_RANDOM",
                MaxmemoryPolicy::VolatileTtl => "VOLATILE_TTL",
                MaxmemoryPolicy::Noeviction => "NOEVICTION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MAXMEMORY_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
                "VOLATILE_LRU" => Some(Self::VolatileLru),
                "ALLKEYS_LRU" => Some(Self::AllkeysLru),
                "VOLATILE_LFU" => Some(Self::VolatileLfu),
                "ALLKEYS_LFU" => Some(Self::AllkeysLfu),
                "VOLATILE_RANDOM" => Some(Self::VolatileRandom),
                "ALLKEYS_RANDOM" => Some(Self::AllkeysRandom),
                "VOLATILE_TTL" => Some(Self::VolatileTtl),
                "NOEVICTION" => Some(Self::Noeviction),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RedisConfigSet70 {
    /// Effective settings for a Redis 7.0 cluster (a combination of settings
    /// defined in \[user_config\] and \[default_config\]).
    #[prost(message, optional, tag = "1")]
    pub effective_config: ::core::option::Option<RedisConfig70>,
    /// User-defined settings for a Redis 7.0 cluster.
    #[prost(message, optional, tag = "2")]
    pub user_config: ::core::option::Option<RedisConfig70>,
    /// Default configuration for a Redis 7.0 cluster.
    #[prost(message, optional, tag = "3")]
    pub default_config: ::core::option::Option<RedisConfig70>,
}