/// A MongoDB Backup resource. For more information, see the
/// [Developer's Guide](/docs/managed-mongodb/concepts).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Backup {
    /// ID of the backup. Required.
    #[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 MongoDB cluster that the backup was created for.
    #[prost(string, tag = "4")]
    pub source_cluster_id: ::prost::alloc::string::String,
    /// Time 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>,
    /// Size of backup in bytes
    #[prost(int64, tag = "7")]
    pub size: i64,
    /// How this backup was created (manual/automatic/etc...)
    #[prost(enumeration = "backup::BackupType", tag = "8")]
    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,
            }
        }
    }
}
/// A ResourcePreset resource for describing hardware configuration presets.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResourcePreset {
    /// ID of the ResourcePreset resource.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// IDs of availability zones where the resource preset is available.
    #[prost(string, repeated, tag = "2")]
    pub zone_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Number of CPU cores for a MongoDB host created with the preset.
    #[prost(int64, tag = "3")]
    pub cores: i64,
    /// RAM volume for a MongoDB host created with the preset, in bytes.
    #[prost(int64, tag = "4")]
    pub memory: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetResourcePresetRequest {
    /// 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.
    /// Acceptable values are 0 to 1000, inclusive. 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
    /// \[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 ResourcePreset resources.
    #[prost(message, repeated, tag = "1")]
    pub resource_presets: ::prost::alloc::vec::Vec<ResourcePreset>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListResourcePresetsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListResourcePresetsRequest.page_token\] parameter in the next list request. Each subsequent
    /// list request will have its own \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod resource_preset_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing ResourcePreset resources.
    #[derive(Debug, Clone)]
    pub struct ResourcePresetServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ResourcePresetServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ResourcePresetServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ResourcePresetServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            ResourcePresetServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the specified ResourcePreset resource.
        ///
        /// To get the list of available ResourcePreset resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetResourcePresetRequest>,
        ) -> std::result::Result<tonic::Response<super::ResourcePreset>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.mdb.mongodb.v1.ResourcePresetService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ResourcePresetService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of available ResourcePreset resources.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListResourcePresetsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListResourcePresetsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.mdb.mongodb.v1.ResourcePresetService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ResourcePresetService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A MongoDB User resource. For more information, see the
/// [Developer's Guide](/docs/managed-mongodb/concepts).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct User {
    /// Name of the MongoDB user.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// ID of the MongoDB cluster the user belongs to.
    #[prost(string, tag = "2")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Set of permissions granted to the user.
    #[prost(message, repeated, tag = "3")]
    pub permissions: ::prost::alloc::vec::Vec<Permission>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Permission {
    /// Name of the database that the permission grants access to.
    #[prost(string, tag = "1")]
    pub database_name: ::prost::alloc::string::String,
    /// MongoDB roles for the \[database_name\] database that the permission grants.
    #[prost(string, repeated, tag = "2")]
    pub roles: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UserSpec {
    /// Name of the MongoDB user.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Password of the MongoDB user.
    #[prost(string, tag = "2")]
    pub password: ::prost::alloc::string::String,
    /// Set of permissions to grant to the user.
    #[prost(message, repeated, tag = "3")]
    pub permissions: ::prost::alloc::vec::Vec<Permission>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetBackupRequest {
    /// ID of the backup to return information about.
    /// 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 {
    /// List of Backup resources.
    #[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 MongoDB 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 MongoDB Backup resources.
    #[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 MongoDB backup.
        ///
        /// To get the list of available MongoDB 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.mongodb.v1.BackupService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.mongodb.v1.BackupService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of 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.mongodb.v1.BackupService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.mongodb.v1.BackupService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns the list of available backups for the specified MongoDB 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.mongodb.v1.BackupService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.BackupService",
                        "Delete",
                    ),
                );
            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 MongoDB 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 MongoDB 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 MongoDB 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 MongoDB 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 MongoDB 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 MongoDB 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 MongoDB 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 be updated.
    /// To get the name of the user, use a \[UserService.List\] request.
    #[prost(string, tag = "2")]
    pub user_name: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the MongoDB User resource should be updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New password for the user.
    #[prost(string, tag = "4")]
    pub password: ::prost::alloc::string::String,
    /// New set of permissions for the user.
    #[prost(message, repeated, tag = "5")]
    pub permissions: ::prost::alloc::vec::Vec<Permission>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateUserMetadata {
    /// ID of the MongoDB 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 MongoDB 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 MongoDB 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,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GrantUserPermissionRequest {
    /// ID of the MongoDB 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 grant the permission to.
    /// To get the name of the user, use a \[UserService.List\] request.
    #[prost(string, tag = "2")]
    pub user_name: ::prost::alloc::string::String,
    /// Permission that should be granted to the specified user.
    #[prost(message, optional, tag = "3")]
    pub permission: ::core::option::Option<Permission>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GrantUserPermissionMetadata {
    /// ID of the MongoDB 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 that is being granted a permission.
    #[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 RevokeUserPermissionRequest {
    /// ID of the MongoDB 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 revoke a permission from.
    /// To get the name of the user, use a \[UserService.List\] request.
    #[prost(string, tag = "2")]
    pub user_name: ::prost::alloc::string::String,
    /// Name of the database that the user should lose access to.
    #[prost(string, tag = "3")]
    pub database_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RevokeUserPermissionMetadata {
    /// ID of the MongoDB cluster the user belongs to.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the user whose permission is being revoked.
    #[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 MongoDB 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 MongoDB User resource.
        ///
        /// To get the list of available MongoDB 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.mongodb.v1.UserService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.mongodb.v1.UserService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of MongoDB 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.mongodb.v1.UserService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.mongodb.v1.UserService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a MongoDB 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.mongodb.v1.UserService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.mongodb.v1.UserService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified MongoDB 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.mongodb.v1.UserService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.mongodb.v1.UserService", "Update"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified MongoDB 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.mongodb.v1.UserService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.mongodb.v1.UserService", "Delete"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Grants permission to the specified MongoDB user.
        pub async fn grant_permission(
            &mut self,
            request: impl tonic::IntoRequest<super::GrantUserPermissionRequest>,
        ) -> 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.mongodb.v1.UserService/GrantPermission",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.UserService",
                        "GrantPermission",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Revokes permission from the specified MongoDB user.
        pub async fn revoke_permission(
            &mut self,
            request: impl tonic::IntoRequest<super::RevokeUserPermissionRequest>,
        ) -> 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.mongodb.v1.UserService/RevokePermission",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.UserService",
                        "RevokePermission",
                    ),
                );
            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>,
}
/// A managed MongoDB cluster. For more information, see the \[documentation\](/docs/managed-mongodb/concepts).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Cluster {
    /// ID of the MongoDB 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 MongoDB 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 MongoDB cluster.
    /// The name is unique within the folder. 1-63 characters long.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the MongoDB cluster. 0-256 characters long.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the MongoDB cluster as `` key:value `` pairs. Maximum 64 per resource.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Deployment environment of the MongoDB cluster.
    #[prost(enumeration = "cluster::Environment", tag = "7")]
    pub environment: i32,
    /// Description of monitoring systems relevant to the MongoDB cluster.
    #[prost(message, repeated, tag = "8")]
    pub monitoring: ::prost::alloc::vec::Vec<Monitoring>,
    /// Configuration of the MongoDB cluster.
    #[prost(message, optional, tag = "9")]
    pub config: ::core::option::Option<ClusterConfig>,
    /// ID of the network that the cluster belongs to.
    #[prost(string, tag = "10")]
    pub network_id: ::prost::alloc::string::String,
    /// Aggregated cluster health.
    #[prost(enumeration = "cluster::Health", tag = "11")]
    pub health: i32,
    /// Current state of the cluster.
    #[prost(enumeration = "cluster::Status", tag = "12")]
    pub status: i32,
    /// Indicates current sharding status of the cluster.
    #[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>,
    /// Deletion Protection inhibits deletion of the cluster
    #[prost(bool, tag = "17")]
    pub deletion_protection: bool,
}
/// Nested message and enum types in `Cluster`.
pub mod cluster {
    /// Deployment environment.
    #[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 {
        /// State of the cluster is unknown (\[Host.health\] for every host in the cluster is UNKNOWN).
        Unknown = 0,
        /// Cluster is alive and well (\[Host.health\] for every host in the cluster is ALIVE).
        Alive = 1,
        /// Cluster is inoperable (\[Host.health\] for every host in the cluster is DEAD).
        Dead = 2,
        /// Cluster is working below capacity (\[Host.health\] for at least one host in the cluster is not ALIVE).
        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 state is unknown.
        Unknown = 0,
        /// Cluster is being created.
        Creating = 1,
        /// Cluster is running normally.
        Running = 2,
        /// Cluster encountered a problem and cannot operate.
        Error = 3,
        /// Cluster is 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,
            }
        }
    }
}
/// Monitoring system.
#[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 MongoDB 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 MongoDB server software. Possible values: `3.6`, `4.0`, `4.2`, `4.4`, `4.4-enterprise`, `5.0`, `5.0-enterprise`, `6.0`, `6.0-enterprise`.
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    /// MongoDB feature compatibility version. See usage details in [MongoDB documentation](<https://docs.mongodb.com/manual/reference/command/setFeatureCompatibilityVersion/>).
    ///
    /// Possible values:
    /// * `3.6` - persist data compatibility for version 3.6. After setting this option the data will not be compatible with 3.4 or lower.
    /// * `4.0` - persist data compatibility for version 4.0. After setting this option the data will not be compatible with 3.6 or lower.
    /// * `4.2` - persist data compatibility for version 4.2. After setting this option the data will not be compatible with 4.0 or lower.
    /// * `4.4` - persist data compatibility for version 4.4. After setting this option the data will not be compatible with 4.2 or lower.
    /// * `5.0` - persist data compatibility for version 5.0. After setting this option the data will not be compatible with 5.0 or lower.
    /// * `6.0` - persist data compatibility for version 6.0. After setting this option the data will not be compatible with 6.0 or lower.
    #[prost(string, tag = "5")]
    pub feature_compatibility_version: ::prost::alloc::string::String,
    /// Time to start the daily backup, in the UTC timezone.
    #[prost(message, optional, tag = "3")]
    pub backup_window_start: ::core::option::Option<
        super::super::super::super::super::google::r#type::TimeOfDay,
    >,
    /// Retain period of automatically created backup in days
    #[prost(message, optional, tag = "9")]
    pub backup_retain_period_days: ::core::option::Option<i64>,
    /// Performance Diagnostic
    #[prost(message, optional, tag = "13")]
    pub performance_diagnostics: ::core::option::Option<PerformanceDiagnosticsConfig>,
    /// Access policy to DB
    #[prost(message, optional, tag = "6")]
    pub access: ::core::option::Option<Access>,
    /// Configuration for MongoDB servers in the cluster.
    #[prost(oneof = "cluster_config::Mongodb", tags = "2, 4, 7, 8, 10, 14, 11, 12, 15")]
    pub mongodb: ::core::option::Option<cluster_config::Mongodb>,
}
/// Nested message and enum types in `ClusterConfig`.
pub mod cluster_config {
    /// Configuration for MongoDB servers in the cluster.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Mongodb {
        /// Configuration and resource allocation for a MongoDB 3.6 cluster.
        #[prost(message, tag = "2")]
        Mongodb36(super::Mongodb36),
        /// Configuration and resource allocation for a MongoDB 4.0 cluster.
        #[prost(message, tag = "4")]
        Mongodb40(super::Mongodb40),
        /// Configuration and resource allocation for a MongoDB 4.2 cluster.
        #[prost(message, tag = "7")]
        Mongodb42(super::Mongodb42),
        /// Configuration and resource allocation for a MongoDB 4.4 cluster.
        #[prost(message, tag = "8")]
        Mongodb44(super::Mongodb44),
        /// Configuration and resource allocation for a MongoDB 5.0 cluster.
        #[prost(message, tag = "10")]
        Mongodb50(super::Mongodb50),
        /// Configuration and resource allocation for a MongoDB 6.0 cluster.
        #[prost(message, tag = "14")]
        Mongodb60(super::Mongodb60),
        /// Configuration and resource allocation for a MongoDB 4.4 Enterprise cluster.
        #[prost(message, tag = "11")]
        Mongodb44Enterprise(super::Mongodb44Enterprise),
        /// Configuration and resource allocation for a MongoDB 5.0 Enterprise cluster.
        #[prost(message, tag = "12")]
        Mongodb50Enterprise(super::Mongodb50Enterprise),
        /// Configuration and resource allocation for a MongoDB 6.0 Enterprise cluster.
        #[prost(message, tag = "15")]
        Mongodb60Enterprise(super::Mongodb60Enterprise),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mongodb36 {
    /// Configuration and resource allocation for mongod in a MongoDB 3.6 cluster.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb3_6::Mongod>,
    /// Configuration and resource allocation for mongocfg in a MongoDB 3.6 cluster.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb3_6::MongoCfg>,
    /// Configuration and resource allocation for mongos in a MongoDB 3.6 cluster.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb3_6::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) in a MongoDB 3.6 cluster.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb3_6::MongoInfra>,
}
/// Nested message and enum types in `Mongodb3_6`.
pub mod mongodb3_6 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for a mongod 3.6 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfigSet36>,
        /// Resources allocated to MongoDB hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfigSet36>,
        /// Resources allocated to mongocfg hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfigSet36>,
        /// Resources allocated to mongos hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<super::config::MongosConfigSet36>,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<super::config::MongoCfgConfigSet36>,
        /// Resources allocated to mongoinfra (mongos+mongocfg) hosts.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mongodb40 {
    /// Configuration and resource allocation for mongod in a MongoDB 4.0 cluster.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb4_0::Mongod>,
    /// Configuration and resource allocation for mongocfg in a MongoDB 4.0 cluster.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb4_0::MongoCfg>,
    /// Configuration and resource allocation for mongos in a MongoDB 4.0 cluster.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb4_0::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) in a MongoDB 4.0 cluster.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb4_0::MongoInfra>,
}
/// Nested message and enum types in `Mongodb4_0`.
pub mod mongodb4_0 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 4.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfigSet40>,
        /// Resources allocated to mongod hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 4.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfigSet40>,
        /// Resources allocated to mongocfg hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 4.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfigSet40>,
        /// Resources allocated to mongos hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<super::config::MongosConfigSet40>,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<super::config::MongoCfgConfigSet40>,
        /// Resources allocated to mongoinfra (mongos+mongocfg) hosts.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mongodb42 {
    /// Configuration and resource allocation for mongod in a MongoDB 4.2 cluster.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb4_2::Mongod>,
    /// Configuration and resource allocation for mongocfg in a MongoDB 4.2 cluster.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb4_2::MongoCfg>,
    /// Configuration and resource allocation for mongos in a MongoDB 4.2 cluster.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb4_2::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) in a MongoDB 4.2 cluster.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb4_2::MongoInfra>,
}
/// Nested message and enum types in `Mongodb4_2`.
pub mod mongodb4_2 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 4.2 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfigSet42>,
        /// Resources allocated to mongod hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 4.2 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfigSet42>,
        /// Resources allocated to mongocfg hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 4.2 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfigSet42>,
        /// Resources allocated to mongos hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<super::config::MongosConfigSet42>,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<super::config::MongoCfgConfigSet42>,
        /// Resources allocated to mongoinfra (mongos+mongocfg) hosts.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mongodb44 {
    /// Configuration and resource allocation for mongod in a MongoDB 4.4 cluster.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb4_4::Mongod>,
    /// Configuration and resource allocation for mongocfg in a MongoDB 4.4 cluster.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb4_4::MongoCfg>,
    /// Configuration and resource allocation for mongos in a MongoDB 4.4 cluster.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb4_4::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) in a MongoDB 4.4 cluster.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb4_4::MongoInfra>,
}
/// Nested message and enum types in `Mongodb4_4`.
pub mod mongodb4_4 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfigSet44>,
        /// Resources allocated to mongod hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfigSet44>,
        /// Resources allocated to mongocfg hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfigSet44>,
        /// Resources allocated to mongos hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<super::config::MongosConfigSet44>,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<super::config::MongoCfgConfigSet44>,
        /// Resources allocated to mongoinfra (mongos+mongocfg) hosts.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mongodb44Enterprise {
    /// Configuration and resource allocation for mongod in a MongoDB 4.4 cluster.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb4_4_enterprise::Mongod>,
    /// Configuration and resource allocation for mongocfg in a MongoDB 4.4 cluster.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb4_4_enterprise::MongoCfg>,
    /// Configuration and resource allocation for mongos in a MongoDB 4.4 cluster.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb4_4_enterprise::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) in a MongoDB 4.4 cluster.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb4_4_enterprise::MongoInfra>,
}
/// Nested message and enum types in `Mongodb4_4_enterprise`.
pub mod mongodb4_4_enterprise {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfigSet44Enterprise>,
        /// Resources allocated to mongod hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfigSet44Enterprise>,
        /// Resources allocated to mongocfg hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfigSet44Enterprise>,
        /// Resources allocated to mongos hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<
            super::config::MongosConfigSet44Enterprise,
        >,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<
            super::config::MongoCfgConfigSet44Enterprise,
        >,
        /// Resources allocated to mongoinfra (mongos+mongocfg) hosts.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mongodb50 {
    /// Configuration and resource allocation for mongod in a MongoDB 5.0 cluster.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb5_0::Mongod>,
    /// Configuration and resource allocation for mongocfg in a MongoDB 5.0 cluster.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb5_0::MongoCfg>,
    /// Configuration and resource allocation for mongos in a MongoDB 5.0 cluster.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb5_0::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) in a MongoDB 5.0 cluster.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb5_0::MongoInfra>,
}
/// Nested message and enum types in `Mongodb5_0`.
pub mod mongodb5_0 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfigSet50>,
        /// Resources allocated to mongod hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfigSet50>,
        /// Resources allocated to mongocfg hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfigSet50>,
        /// Resources allocated to mongos hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<super::config::MongosConfigSet50>,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<super::config::MongoCfgConfigSet50>,
        /// Resources allocated to mongoinfra (mongos+mongocfg) hosts.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mongodb50Enterprise {
    /// Configuration and resource allocation for mongod in a MongoDB 5.0 cluster.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb5_0_enterprise::Mongod>,
    /// Configuration and resource allocation for mongocfg in a MongoDB 5.0 cluster.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb5_0_enterprise::MongoCfg>,
    /// Configuration and resource allocation for mongos in a MongoDB 5.0 cluster.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb5_0_enterprise::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) in a MongoDB 5.0 cluster.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb5_0_enterprise::MongoInfra>,
}
/// Nested message and enum types in `Mongodb5_0_enterprise`.
pub mod mongodb5_0_enterprise {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfigSet50Enterprise>,
        /// Resources allocated to mongod hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfigSet50Enterprise>,
        /// Resources allocated to mongocfg hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfigSet50Enterprise>,
        /// Resources allocated to mongos hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<
            super::config::MongosConfigSet50Enterprise,
        >,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<
            super::config::MongoCfgConfigSet50Enterprise,
        >,
        /// Resources allocated to mongoinfra (mongos+mongocfg) hosts.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mongodb60 {
    /// Configuration and resource allocation for mongod in a MongoDB 6.0 cluster.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb6_0::Mongod>,
    /// Configuration and resource allocation for mongocfg in a MongoDB 6.0 cluster.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb6_0::MongoCfg>,
    /// Configuration and resource allocation for mongos in a MongoDB 6.0 cluster.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb6_0::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) in a MongoDB 6.0 cluster.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb6_0::MongoInfra>,
}
/// Nested message and enum types in `Mongodb6_0`.
pub mod mongodb6_0 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfigSet60>,
        /// Resources allocated to mongod hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfigSet60>,
        /// Resources allocated to mongocfg hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfigSet60>,
        /// Resources allocated to mongos hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<super::config::MongosConfigSet60>,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<super::config::MongoCfgConfigSet60>,
        /// Resources allocated to mongoinfra (mongos+mongocfg) hosts.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mongodb60Enterprise {
    /// Configuration and resource allocation for mongod in a MongoDB 6.0 cluster.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb6_0_enterprise::Mongod>,
    /// Configuration and resource allocation for mongocfg in a MongoDB 6.0 cluster.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb6_0_enterprise::MongoCfg>,
    /// Configuration and resource allocation for mongos in a MongoDB 6.0 cluster.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb6_0_enterprise::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) in a MongoDB 6.0 cluster.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb6_0_enterprise::MongoInfra>,
}
/// Nested message and enum types in `Mongodb6_0_enterprise`.
pub mod mongodb6_0_enterprise {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfigSet60Enterprise>,
        /// Resources allocated to mongod hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfigSet60Enterprise>,
        /// Resources allocated to mongocfg hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfigSet60Enterprise>,
        /// Resources allocated to mongos hosts.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<
            super::config::MongosConfigSet60Enterprise,
        >,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<
            super::config::MongoCfgConfigSet60Enterprise,
        >,
        /// Resources allocated to mongoinfra (mongos+mongocfg) hosts.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Shard {
    /// Name of the shard.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// ID of the cluster that the shard belongs to.
    #[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 MongoDB 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 MongoDB host. 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 MongoDB host resides.
    #[prost(string, tag = "3")]
    pub zone_id: ::prost::alloc::string::String,
    /// Resources allocated to the MongoDB host.
    #[prost(message, optional, tag = "4")]
    pub resources: ::core::option::Option<Resources>,
    /// Role of the host in the cluster.
    #[prost(enumeration = "host::Role", tag = "5")]
    pub role: i32,
    /// Status code of the aggregated health of the host.
    #[prost(enumeration = "host::Health", tag = "6")]
    pub health: i32,
    /// Services provided by the host.
    #[prost(message, repeated, tag = "7")]
    pub services: ::prost::alloc::vec::Vec<Service>,
    /// ID of the subnet that the host belongs to.
    #[prost(string, tag = "8")]
    pub subnet_id: ::prost::alloc::string::String,
    /// Flag showing public IP assignment status to this host.
    #[prost(bool, tag = "9")]
    pub assign_public_ip: bool,
    /// Shard which this host belongs to.
    #[prost(string, tag = "10")]
    pub shard_name: ::prost::alloc::string::String,
    /// Host type
    #[prost(enumeration = "host::Type", tag = "11")]
    pub r#type: i32,
}
/// 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 Type {
        Unspecified = 0,
        /// A mongod host.
        Mongod = 1,
        /// A mongos host.
        Mongos = 2,
        /// A mongocfg host.
        Mongocfg = 3,
        /// A mongoinfra (mongos+mongocfg) host.
        Mongoinfra = 4,
    }
    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::Mongod => "MONGOD",
                Type::Mongos => "MONGOS",
                Type::Mongocfg => "MONGOCFG",
                Type::Mongoinfra => "MONGOINFRA",
            }
        }
        /// 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),
                "MONGOD" => Some(Self::Mongod),
                "MONGOS" => Some(Self::Mongos),
                "MONGOCFG" => Some(Self::Mongocfg),
                "MONGOINFRA" => Some(Self::Mongoinfra),
                _ => None,
            }
        }
    }
    #[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.
        Unknown = 0,
        /// Host is the primary MongoDB server in the cluster.
        Primary = 1,
        /// Host is a secondary MongoDB server in the cluster.
        Secondary = 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::Primary => "PRIMARY",
                Role::Secondary => "SECONDARY",
            }
        }
        /// 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),
                "PRIMARY" => Some(Self::Primary),
                "SECONDARY" => Some(Self::Secondary),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Health {
        /// Health of the host is unknown.
        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.
    #[prost(enumeration = "service::Type", tag = "1")]
    pub r#type: i32,
    /// Status code of server availability.
    #[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 {
        Unspecified = 0,
        /// The host is running a mongod daemon.
        Mongod = 1,
        /// The host is running a mongos daemon.
        Mongos = 2,
        /// The host is running a MongoDB config server.
        Mongocfg = 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::Mongod => "MONGOD",
                Type::Mongos => "MONGOS",
                Type::Mongocfg => "MONGOCFG",
            }
        }
        /// 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),
                "MONGOD" => Some(Self::Mongod),
                "MONGOS" => Some(Self::Mongos),
                "MONGOCFG" => Some(Self::Mongocfg),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Health {
        /// Health of the server is unknown.
        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-mongodb/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-hdd - network HDD drive,
    /// * 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 DataTransfer.
    #[prost(bool, tag = "3")]
    pub data_transfer: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PerformanceDiagnosticsConfig {
    #[prost(bool, tag = "1")]
    pub profiling_enabled: bool,
}
/// A MongoDB Database resource. For more information, see the
/// [Developer's Guide](/docs/managed-mongodb/concepts).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Database {
    /// Name of the database.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// ID of the MongoDB cluster that the database belongs to.
    #[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 DatabaseSpec {
    /// Name of the MongoDB database. 1-63 characters long.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDatabaseRequest {
    /// ID of the MongoDB cluster that the database 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 MongoDB database to return.
    /// To get the name of the database use a \[DatabaseService.List\] request.
    #[prost(string, tag = "2")]
    pub database_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDatabasesRequest {
    /// ID of the MongoDB cluster to list databases 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 \[ListDatabasesResponse.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
    /// \[ListDatabasesResponse.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 ListDatabasesResponse {
    /// List of MongoDB databases.
    #[prost(message, repeated, tag = "1")]
    pub databases: ::prost::alloc::vec::Vec<Database>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListDatabasesRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListDatabasesRequest.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 CreateDatabaseRequest {
    /// ID of the MongoDB cluster to create a database in.
    /// To get the cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Configuration of the database to create.
    #[prost(message, optional, tag = "2")]
    pub database_spec: ::core::option::Option<DatabaseSpec>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateDatabaseMetadata {
    /// ID of the MongoDB cluster where a database is being created.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the MongoDB database that is being created.
    #[prost(string, tag = "2")]
    pub database_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteDatabaseRequest {
    /// ID of the MongoDB cluster to delete a database 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 database to delete.
    /// To get the name of the database, use a \[DatabaseService.List\] request.
    #[prost(string, tag = "2")]
    pub database_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteDatabaseMetadata {
    /// ID of the MongoDB cluster where a database is being deleted.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the MongoDB database that is being deleted.
    #[prost(string, tag = "2")]
    pub database_name: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod database_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 MongoDB Database resources.
    #[derive(Debug, Clone)]
    pub struct DatabaseServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl DatabaseServiceClient<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> DatabaseServiceClient<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,
        ) -> DatabaseServiceClient<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,
        {
            DatabaseServiceClient::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 MongoDB Database resource.
        ///
        /// To get the list of available MongoDB Database resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDatabaseRequest>,
        ) -> std::result::Result<tonic::Response<super::Database>, 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.mongodb.v1.DatabaseService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.mongodb.v1.DatabaseService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of MongoDB Database resources in the specified cluster.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListDatabasesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListDatabasesResponse>,
            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.mongodb.v1.DatabaseService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.DatabaseService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new MongoDB database in the specified cluster.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateDatabaseRequest>,
        ) -> 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.mongodb.v1.DatabaseService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.DatabaseService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified MongoDB database.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteDatabaseRequest>,
        ) -> 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.mongodb.v1.DatabaseService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.DatabaseService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetClusterRequest {
    /// ID of the MongoDB Cluster resource 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 MongoDB 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.
    /// Acceptable values are 0 to 1000, inclusive. Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\]
    /// to the \[ListClustersResponse.next_page_token\] returned by the previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters resources 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 1-63 characters long and match the regular expression `\[a-zA-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 MongoDB Cluster resources.
    #[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 MongoDB cluster in.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the MongoDB cluster. The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the MongoDB cluster.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the MongoDB cluster as `` key:value `` pairs. Maximum 64 per resource.
    /// 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 MongoDB cluster.
    #[prost(enumeration = "cluster::Environment", tag = "5")]
    pub environment: i32,
    /// Configuration and resources for hosts that should be created for the MongoDB cluster.
    #[prost(message, optional, tag = "6")]
    pub config_spec: ::core::option::Option<ConfigSpec>,
    /// Descriptions of databases to be created in the MongoDB cluster.
    #[prost(message, repeated, tag = "7")]
    pub database_specs: ::prost::alloc::vec::Vec<DatabaseSpec>,
    /// Descriptions of database users to be created in the MongoDB cluster.
    #[prost(message, repeated, tag = "8")]
    pub user_specs: ::prost::alloc::vec::Vec<UserSpec>,
    /// Individual configurations for hosts that should be created for the MongoDB cluster.
    #[prost(message, repeated, tag = "9")]
    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,
    /// User security groups
    #[prost(string, repeated, tag = "11")]
    pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Deletion Protection inhibits deletion of the cluster
    #[prost(bool, tag = "12")]
    pub deletion_protection: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateClusterMetadata {
    /// ID of the MongoDB 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 MongoDB Cluster resource to update.
    /// To get the MongoDB 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 MongoDB Cluster resource should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New description of the MongoDB cluster.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the MongoDB cluster as `` key:value `` pairs. Maximum 64 per resource.
    /// 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,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateClusterMetadata {
    /// ID of the MongoDB Cluster resource 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 MongoDB cluster to delete.
    /// To get the MongoDB 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 MongoDB 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 MongoDB 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 MongoDB 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 MongoDB 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 MongoDB 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 MongoDB 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 MongoDB 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 destnation 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 BackupClusterRequest {
    /// ID of the MongoDB cluster to back up.
    /// To get the MongoDB 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 MongoDB 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 MongoDB cluster. The name must be unique within the folder.
    /// The name can't be changed after the MongoDB cluster is created.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the new MongoDB cluster.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the MongoDB cluster as `` key:value `` pairs. Maximum 64 per resource.
    /// 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 MongoDB cluster.
    #[prost(enumeration = "cluster::Environment", tag = "5")]
    pub environment: i32,
    /// Configuration for the MongoDB cluster to be created.
    #[prost(message, optional, tag = "6")]
    pub config_spec: ::core::option::Option<ConfigSpec>,
    /// Configurations for MongoDB 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 MongoDB cluster in.
    #[prost(string, tag = "8")]
    pub network_id: ::prost::alloc::string::String,
    /// Required. ID of the folder to create the MongoDB cluster in.
    #[prost(string, tag = "9")]
    pub folder_id: ::prost::alloc::string::String,
    /// Specification of the moment to which the MongoDB cluster should be restored.
    #[prost(message, optional, tag = "10")]
    pub recovery_target_spec: ::core::option::Option<
        restore_cluster_request::RecoveryTargetSpec,
    >,
    /// User security groups
    #[prost(string, repeated, tag = "11")]
    pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Deletion Protection inhibits deletion of the cluster
    #[prost(bool, tag = "12")]
    pub deletion_protection: bool,
}
/// Nested message and enum types in `RestoreClusterRequest`.
pub mod restore_cluster_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RecoveryTargetSpec {
        /// Timestamp of the recovery target
        #[prost(int64, tag = "1")]
        pub timestamp: i64,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RestoreClusterMetadata {
    /// ID of the new MongoDB 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 RescheduleMaintenanceRequest {
    /// ID of the MongoDB 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,
            }
        }
    }
}
/// Rescheduled maintenance operation metadata.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RescheduleMaintenanceMetadata {
    /// Required. ID of the MongoDB 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 MongoDB cluster to request logs for.
    /// To get the MongoDB 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>,
    /// Type of the service to request logs about.
    #[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.
    /// Acceptable values are 0 to 1000, inclusive. Default value: 100.
    #[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 MongoDB activity.
        Mongod = 1,
        Mongos = 2,
        Mongocfg = 3,
        /// MongoDB Enterprise audit logs
        Audit = 4,
    }
    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::Mongod => "MONGOD",
                ServiceType::Mongos => "MONGOS",
                ServiceType::Mongocfg => "MONGOCFG",
                ServiceType::Audit => "AUDIT",
            }
        }
        /// 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),
                "MONGOD" => Some(Self::Mongod),
                "MONGOS" => Some(Self::Mongos),
                "MONGOCFG" => Some(Self::Mongocfg),
                "AUDIT" => Some(Self::Audit),
                _ => 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 MongoDB 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.message.hostname\], \[LogRecord.logs.message.severity\] fields.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 1-63 characters long and match the regular expression `\[a-z0-9.-\]{1,61}`.
    /// Examples of a filter: `message.hostname='node1.db.cloud.yandex.net'`, `message.severity IN ('E', 'F')`
    #[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 MongoDB activity.
        Mongod = 1,
        Mongos = 2,
        Mongocfg = 3,
        /// MongoDB Enterprise audit logs
        Audit = 4,
    }
    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::Mongod => "MONGOD",
                ServiceType::Mongos => "MONGOS",
                ServiceType::Mongocfg => "MONGOCFG",
                ServiceType::Audit => "AUDIT",
            }
        }
        /// 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),
                "MONGOD" => Some(Self::Mongod),
                "MONGOS" => Some(Self::Mongos),
                "MONGOCFG" => Some(Self::Mongocfg),
                "AUDIT" => Some(Self::Audit),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterOperationsRequest {
    /// ID of the MongoDB Cluster resource 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.
    /// Acceptable values are 0 to 1000, inclusive. Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the
    /// \[ListClusterOperationsResponse.next_page_token\] returned by 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 Operation resources for the specified MongoDB 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 MongoDB cluster.
    /// To get the MongoDB 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.
    /// Acceptable values are 0 to 1000, inclusive. 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
    /// \[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 MongoDB Backup resources.
    #[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 MongoDB cluster.
    /// To get the MongoDB 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.
    /// Acceptable values are 0 to 1000, inclusive. Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the
    /// \[ListClusterHostsResponse.next_page_token\] returned by 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 Host resources.
    #[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 MongoDB cluster to add hosts to.
    /// To get the MongoDB cluster ID use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Configurations for MongoDB 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 MongoDB 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 MongoDB cluster to remove hosts from.
    /// To get the MongoDB 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 MongoDB 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 EnableClusterShardingRequest {
    /// ID of the MongoDB cluster to enable sharding for.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// mongocfg specification for sharding.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<enable_cluster_sharding_request::MongoCfg>,
    /// mongos specification for sharding.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<enable_cluster_sharding_request::Mongos>,
    /// Configurations for mongos and mongocfg hosts.
    #[prost(message, repeated, tag = "4")]
    pub host_specs: ::prost::alloc::vec::Vec<HostSpec>,
    /// mongos specification for sharding.
    #[prost(message, optional, tag = "5")]
    pub mongoinfra: ::core::option::Option<enable_cluster_sharding_request::MongoInfra>,
}
/// Nested message and enum types in `EnableClusterShardingRequest`.
pub mod enable_cluster_sharding_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Resources for mongocfg hosts.
        #[prost(message, optional, tag = "1")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Resources for mongos hosts.
        #[prost(message, optional, tag = "1")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        /// Resources for mongoinfra (mongos+mongocfg) hosts.
        #[prost(message, optional, tag = "1")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EnableClusterShardingMetadata {
    /// ID of the MongoDB cluster that sharding is being enabled for.
    #[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 GetClusterShardRequest {
    /// ID of the MongoDB cluster that 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 MongoDB shard to return.
    /// To get the name of the shard 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 MongoDB cluster to list databases 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.
    #[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 MongoDB 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\] 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 MongoDB cluster to add a shard 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 MongoDB shard to create.
    #[prost(string, tag = "2")]
    pub shard_name: ::prost::alloc::string::String,
    /// Configurations for mongod hosts to be created with the shard.
    #[prost(message, repeated, tag = "3")]
    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 MongoDB cluster that a shard is being added to.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the shard being added.
    #[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 MongoDB cluster to delete 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 MongoDB shard to delete.
    /// To get the name of the shard 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 MongoDB cluster that a shard is being deleted in.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the shard 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 ResetupHostsRequest {
    /// Required. ID of the MongoDB cluster.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Required. Name of the hosts to resetup.
    #[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 ResetupHostsMetadata {
    /// Required. ID of the MongoDB cluster.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Required. The name of hosts to resetup.
    #[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 RestartHostsRequest {
    /// Required. ID of the MongoDB cluster.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Required. Name of the hosts to restart.
    #[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 RestartHostsMetadata {
    /// Required. ID of the MongoDB cluster.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Required. The name of hosts to restart.
    #[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 StepdownHostsRequest {
    /// Required. ID of the MongoDB cluster.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Required. Name of the hosts to resetup.
    #[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 StepdownHostsMetadata {
    /// Required. ID of the MongoDB cluster.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Required. The name of hosts to resetup.
    #[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 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 network ID is set in the \[Cluster.network_id\] field.
    #[prost(string, tag = "2")]
    pub subnet_id: ::prost::alloc::string::String,
    /// Whether the host should get a public IP address on creation.
    ///
    /// After a host has been created, this setting cannot be changed. To remove an assigned public IP, or to assign
    /// a public IP to a host without one, recreate the host with \[assign_public_ip\] set as needed.
    ///
    /// Possible values:
    /// * false - don't assign a public IP to the host.
    /// * true - the host should have a public IP address.
    #[prost(bool, tag = "3")]
    pub assign_public_ip: bool,
    /// Type of the host to be deployed.
    #[prost(enumeration = "host::Type", tag = "4")]
    pub r#type: i32,
    /// Name of the shard that the host belongs to.
    #[prost(string, tag = "5")]
    pub shard_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongodbSpec36 {
    /// Configuration and resource allocation for mongod 3.6 hosts.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb_spec3_6::Mongod>,
    /// Configuration and resource allocation for mongocfg 3.6 hosts.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb_spec3_6::MongoCfg>,
    /// Configuration and resource allocation for mongos 3.6 hosts.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb_spec3_6::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) 3.6 hosts.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb_spec3_6::MongoInfra>,
}
/// Nested message and enum types in `MongodbSpec3_6`.
pub mod mongodb_spec3_6 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 3.6 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfig36>,
        /// Resources allocated to each mongod host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 3.6 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfig36>,
        /// Resources allocated to each mongocfg host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 3.6 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfig36>,
        /// Resources allocated to each mongos host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        /// Configuration for mongoinfra 3.6 hosts.
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<super::config::MongosConfig36>,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<super::config::MongoCfgConfig36>,
        /// Resources allocated to each mongoinfra (mongos+mongocfg) host.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongodbSpec40 {
    /// Configuration and resource allocation for mongod 4.0 hosts.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb_spec4_0::Mongod>,
    /// Configuration and resource allocation for mongocfg 4.0 hosts.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb_spec4_0::MongoCfg>,
    /// Configuration and resource allocation for mongos 4.0 hosts.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb_spec4_0::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) 4.0 hosts.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb_spec4_0::MongoInfra>,
}
/// Nested message and enum types in `MongodbSpec4_0`.
pub mod mongodb_spec4_0 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 4.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfig40>,
        /// Resources allocated to each mongod host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 4.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfig40>,
        /// Resources allocated to each mongocfg host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 4.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfig40>,
        /// Resources allocated to each mongos host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        /// Configuration for mongoinfra 4.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<super::config::MongosConfig40>,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<super::config::MongoCfgConfig40>,
        /// Resources allocated to each mongoinfra (mongos+mongocfg) host.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongodbSpec42 {
    /// Configuration and resource allocation for mongod 4.2 hosts.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb_spec4_2::Mongod>,
    /// Configuration and resource allocation for mongocfg 4.2 hosts.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb_spec4_2::MongoCfg>,
    /// Configuration and resource allocation for mongos 4.2 hosts.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb_spec4_2::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) 4.2 hosts.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb_spec4_2::MongoInfra>,
}
/// Nested message and enum types in `MongodbSpec4_2`.
pub mod mongodb_spec4_2 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 4.2 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfig42>,
        /// Resources allocated to each mongod host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 4.2 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfig42>,
        /// Resources allocated to each mongocfg host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 4.2 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfig42>,
        /// Resources allocated to each mongos host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        /// Configuration for mongoinfra 4.2 hosts.
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<super::config::MongosConfig42>,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<super::config::MongoCfgConfig42>,
        /// Resources allocated to each mongoinfra (mongos+mongocfg) host.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongodbSpec44 {
    /// Configuration and resource allocation for mongod 4.4 hosts.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb_spec4_4::Mongod>,
    /// Configuration and resource allocation for mongocfg 4.4 hosts.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb_spec4_4::MongoCfg>,
    /// Configuration and resource allocation for mongos 4.4 hosts.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb_spec4_4::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) 4.4 hosts.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb_spec4_4::MongoInfra>,
}
/// Nested message and enum types in `MongodbSpec4_4`.
pub mod mongodb_spec4_4 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfig44>,
        /// Resources allocated to each mongod host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfig44>,
        /// Resources allocated to each mongocfg host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfig44>,
        /// Resources allocated to each mongos host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        /// Configuration for mongoinfra 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<super::config::MongosConfig44>,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<super::config::MongoCfgConfig44>,
        /// Resources allocated to each mongoinfra (mongos+mongocfg) host.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongodbSpec44Enterprise {
    /// Configuration and resource allocation for mongod 4.4 hosts.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb_spec4_4_enterprise::Mongod>,
    /// Configuration and resource allocation for mongocfg 4.4 hosts.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb_spec4_4_enterprise::MongoCfg>,
    /// Configuration and resource allocation for mongos 4.4 hosts.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb_spec4_4_enterprise::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) 4.4 hosts.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb_spec4_4_enterprise::MongoInfra>,
}
/// Nested message and enum types in `MongodbSpec4_4_enterprise`.
pub mod mongodb_spec4_4_enterprise {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfig44Enterprise>,
        /// Resources allocated to each mongod host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfig44Enterprise>,
        /// Resources allocated to each mongocfg host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfig44Enterprise>,
        /// Resources allocated to each mongos host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        /// Configuration for mongoinfra 4.4 hosts.
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<
            super::config::MongosConfig44Enterprise,
        >,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<
            super::config::MongoCfgConfig44Enterprise,
        >,
        /// Resources allocated to each mongoinfra (mongos+mongocfg) host.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongodbSpec50 {
    /// Configuration and resource allocation for mongod 5.0 hosts.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb_spec5_0::Mongod>,
    /// Configuration and resource allocation for mongocfg 5.0 hosts.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb_spec5_0::MongoCfg>,
    /// Configuration and resource allocation for mongos 5.0 hosts.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb_spec5_0::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) 5.0 hosts.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb_spec5_0::MongoInfra>,
}
/// Nested message and enum types in `MongodbSpec5_0`.
pub mod mongodb_spec5_0 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfig50>,
        /// Resources allocated to each mongod host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfig50>,
        /// Resources allocated to each mongocfg host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfig50>,
        /// Resources allocated to each mongos host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        /// Configuration for mongoinfra 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<super::config::MongosConfig50>,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<super::config::MongoCfgConfig50>,
        /// Resources allocated to each mongoinfra (mongos+mongocfg) host.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongodbSpec50Enterprise {
    /// Configuration and resource allocation for mongod 5.0 hosts.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb_spec5_0_enterprise::Mongod>,
    /// Configuration and resource allocation for mongocfg 5.0 hosts.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb_spec5_0_enterprise::MongoCfg>,
    /// Configuration and resource allocation for mongos 5.0 hosts.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb_spec5_0_enterprise::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) 5.0 hosts.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb_spec5_0_enterprise::MongoInfra>,
}
/// Nested message and enum types in `MongodbSpec5_0_enterprise`.
pub mod mongodb_spec5_0_enterprise {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfig50Enterprise>,
        /// Resources allocated to each mongod host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfig50Enterprise>,
        /// Resources allocated to each mongocfg host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfig50Enterprise>,
        /// Resources allocated to each mongos host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        /// Configuration for mongoinfra 5.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<
            super::config::MongosConfig50Enterprise,
        >,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<
            super::config::MongoCfgConfig50Enterprise,
        >,
        /// Resources allocated to each mongoinfra (mongos+mongocfg) host.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongodbSpec60 {
    /// Configuration and resource allocation for mongod 6.0 hosts.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb_spec6_0::Mongod>,
    /// Configuration and resource allocation for mongocfg 6.0 hosts.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb_spec6_0::MongoCfg>,
    /// Configuration and resource allocation for mongos 6.0 hosts.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb_spec6_0::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) 6.0 hosts.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb_spec6_0::MongoInfra>,
}
/// Nested message and enum types in `MongodbSpec6_0`.
pub mod mongodb_spec6_0 {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfig60>,
        /// Resources allocated to each mongod host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfig60>,
        /// Resources allocated to each mongocfg host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfig60>,
        /// Resources allocated to each mongos host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        /// Configuration for mongoinfra 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<super::config::MongosConfig60>,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<super::config::MongoCfgConfig60>,
        /// Resources allocated to each mongoinfra (mongos+mongocfg) host.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MongodbSpec60Enterprise {
    /// Configuration and resource allocation for mongod 6.0 hosts.
    #[prost(message, optional, tag = "1")]
    pub mongod: ::core::option::Option<mongodb_spec6_0_enterprise::Mongod>,
    /// Configuration and resource allocation for mongocfg 6.0 hosts.
    #[prost(message, optional, tag = "2")]
    pub mongocfg: ::core::option::Option<mongodb_spec6_0_enterprise::MongoCfg>,
    /// Configuration and resource allocation for mongos 6.0 hosts.
    #[prost(message, optional, tag = "3")]
    pub mongos: ::core::option::Option<mongodb_spec6_0_enterprise::Mongos>,
    /// Configuration and resource allocation for mongoinfra (mongos+mongocfg) 6.0 hosts.
    #[prost(message, optional, tag = "4")]
    pub mongoinfra: ::core::option::Option<mongodb_spec6_0_enterprise::MongoInfra>,
}
/// Nested message and enum types in `MongodbSpec6_0_enterprise`.
pub mod mongodb_spec6_0_enterprise {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongod {
        /// Configuration for mongod 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongodConfig60Enterprise>,
        /// Resources allocated to each mongod host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoCfg {
        /// Configuration for mongocfg 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongoCfgConfig60Enterprise>,
        /// Resources allocated to each mongocfg host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Mongos {
        /// Configuration for mongos 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config: ::core::option::Option<super::config::MongosConfig60Enterprise>,
        /// Resources allocated to each mongos host.
        #[prost(message, optional, tag = "2")]
        pub resources: ::core::option::Option<super::Resources>,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MongoInfra {
        /// Configuration for mongoinfra 6.0 hosts.
        #[prost(message, optional, tag = "1")]
        pub config_mongos: ::core::option::Option<
            super::config::MongosConfig60Enterprise,
        >,
        #[prost(message, optional, tag = "2")]
        pub config_mongocfg: ::core::option::Option<
            super::config::MongoCfgConfig60Enterprise,
        >,
        /// Resources allocated to each mongoinfra (mongos+mongocfg) host.
        #[prost(message, optional, tag = "3")]
        pub resources: ::core::option::Option<super::Resources>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConfigSpec {
    /// Version of MongoDB used in the cluster. Possible values: `3.6`, `4.0`, `4.2`, `4.4`, `4.4-enterprise`, `5.0`, `5.0-enterprise`, `6.0`, `6.0-enterprise`.
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    /// MongoDB feature compatibility version. See usage details in [MongoDB documentation](<https://docs.mongodb.com/manual/reference/command/setFeatureCompatibilityVersion/>).
    ///
    /// Possible values:
    /// * `3.6` - persist data compatibility for version 3.6. After setting this option the data will not be compatible with 3.4 or older.
    /// * `4.0` - persist data compatibility for version 4.0. After setting this option the data will not be compatible with 3.6 or older.
    /// * `4.2` - persist data compatibility for version 4.2. After setting this option the data will not be compatible with 4.0 or older.
    /// * `4.4` - persist data compatibility for version 4.4. After setting this option the data will not be compatible with 4.2 or older.
    /// * `5.0` - persist data compatibility for version 5.0. After setting this option the data will not be compatible with 4.4 or older.
    /// * `6.0` - persist data compatibility for version 6.0. After setting this option the data will not be compatible with 5.0 or older.
    #[prost(string, tag = "5")]
    pub feature_compatibility_version: ::prost::alloc::string::String,
    /// Time to start the daily backup, in the UTC timezone.
    #[prost(message, optional, tag = "3")]
    pub backup_window_start: ::core::option::Option<
        super::super::super::super::super::google::r#type::TimeOfDay,
    >,
    /// Retain period of automatically created backup in days
    #[prost(message, optional, tag = "9")]
    pub backup_retain_period_days: ::core::option::Option<i64>,
    /// Performance Diagnosics configuration
    #[prost(message, optional, tag = "13")]
    pub performance_diagnostics: ::core::option::Option<PerformanceDiagnosticsConfig>,
    /// Access policy to DB
    #[prost(message, optional, tag = "6")]
    pub access: ::core::option::Option<Access>,
    #[prost(oneof = "config_spec::MongodbSpec", tags = "2, 4, 7, 8, 10, 14, 11, 12, 15")]
    pub mongodb_spec: ::core::option::Option<config_spec::MongodbSpec>,
}
/// Nested message and enum types in `ConfigSpec`.
pub mod config_spec {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum MongodbSpec {
        /// Configuration and resource allocation for a MongoDB 3.6 cluster.
        #[prost(message, tag = "2")]
        MongodbSpec36(super::MongodbSpec36),
        /// Configuration and resource allocation for a MongoDB 4.0 cluster.
        #[prost(message, tag = "4")]
        MongodbSpec40(super::MongodbSpec40),
        /// Configuration and resource allocation for a MongoDB 4.2 cluster.
        #[prost(message, tag = "7")]
        MongodbSpec42(super::MongodbSpec42),
        /// Configuration and resource allocation for a MongoDB 4.4 cluster.
        #[prost(message, tag = "8")]
        MongodbSpec44(super::MongodbSpec44),
        /// Configuration and resource allocation for a MongoDB 5.0 cluster.
        #[prost(message, tag = "10")]
        MongodbSpec50(super::MongodbSpec50),
        /// Configuration and resource allocation for a MongoDB 6.0 cluster.
        #[prost(message, tag = "14")]
        MongodbSpec60(super::MongodbSpec60),
        /// Configuration and resource allocation for a MongoDB 4.4 Enterprise cluster.
        #[prost(message, tag = "11")]
        MongodbSpec44Enterprise(super::MongodbSpec44Enterprise),
        /// Configuration and resource allocation for a MongoDB 5.0 Enterprise cluster.
        #[prost(message, tag = "12")]
        MongodbSpec50Enterprise(super::MongodbSpec50Enterprise),
        /// Configuration and resource allocation for a MongoDB 6.0 Enterprise cluster.
        #[prost(message, tag = "15")]
        MongodbSpec60Enterprise(super::MongodbSpec60Enterprise),
    }
}
/// 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 MongoDB Cluster resources.
    #[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 MongoDB Cluster resource.
        ///
        /// To get the list of available MongoDB Cluster resources, 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.mongodb.v1.ClusterService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.mongodb.v1.ClusterService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of MongoDB Cluster resources 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.mongodb.v1.ClusterService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.mongodb.v1.ClusterService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a MongoDB 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.mongodb.v1.ClusterService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified MongoDB 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.mongodb.v1.ClusterService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified MongoDB 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.mongodb.v1.ClusterService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Start the specified MongoDB 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.mongodb.v1.ClusterService/Start",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "Start",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Stop the specified MongoDB 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.mongodb.v1.ClusterService/Stop",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.mongodb.v1.ClusterService", "Stop"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Moves the specified MongoDB 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.mongodb.v1.ClusterService/Move",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.mongodb.v1.ClusterService", "Move"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a backup for the specified MongoDB 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.mongodb.v1.ClusterService/Backup",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "Backup",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new MongoDB 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.mongodb.v1.ClusterService/Restore",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.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.mongodb.v1.ClusterService/RescheduleMaintenance",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "RescheduleMaintenance",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves logs for the specified MongoDB cluster.
        /// See the [Logs](/yandex-mdb-guide/concepts/logs.html) section in the developers guide for detailed logs description.
        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.mongodb.v1.ClusterService/ListLogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.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.mongodb.v1.ClusterService/StreamLogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "StreamLogs",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        /// Retrieves the list of Operation resources 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.mongodb.v1.ClusterService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of available backups for the specified MongoDB 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.mongodb.v1.ClusterService/ListBackups",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.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.mongodb.v1.ClusterService/ListHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.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.mongodb.v1.ClusterService/AddHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.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.mongodb.v1.ClusterService/DeleteHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "DeleteHosts",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Enables sharding for the cluster:
        /// creates 3 mongoinfra (or 3 mongocfg and 2 mongos) hosts
        /// that would support adding and using shards in the cluster.
        pub async fn enable_sharding(
            &mut self,
            request: impl tonic::IntoRequest<super::EnableClusterShardingRequest>,
        ) -> 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.mongodb.v1.ClusterService/EnableSharding",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "EnableSharding",
                    ),
                );
            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.mongodb.v1.ClusterService/GetShard",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.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.mongodb.v1.ClusterService/ListShards",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.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.mongodb.v1.ClusterService/AddShard",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.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.mongodb.v1.ClusterService/DeleteShard",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "DeleteShard",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Resetups hosts.
        pub async fn resetup_hosts(
            &mut self,
            request: impl tonic::IntoRequest<super::ResetupHostsRequest>,
        ) -> 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.mongodb.v1.ClusterService/ResetupHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "ResetupHosts",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Restarts hosts.
        pub async fn restart_hosts(
            &mut self,
            request: impl tonic::IntoRequest<super::RestartHostsRequest>,
        ) -> 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.mongodb.v1.ClusterService/RestartHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "RestartHosts",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Stepdown hosts.
        pub async fn stepdown_hosts(
            &mut self,
            request: impl tonic::IntoRequest<super::StepdownHostsRequest>,
        ) -> 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.mongodb.v1.ClusterService/StepdownHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.mongodb.v1.ClusterService",
                        "StepdownHosts",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}