yandex_cloud/

yandex.cloud.mdb.postgresql.v1.rs

/// A PostgreSQL Backup resource. For more information, see
/// the [Developer's Guide](/docs/managed-postgresql/concepts/backup).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Backup {
    /// Required. ID of the backup.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the backup belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Creation timestamp in \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format
    /// (i.e. when the backup operation was completed).
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// ID of the PostgreSQL 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>,
    /// Size of backup, in bytes
    #[prost(int64, tag = "6")]
    pub size: i64,
    /// How this backup was created (manual/automatic/etc...)
    #[prost(enumeration = "backup::BackupCreationType", tag = "7")]
    pub r#type: i32,
    /// Method of backup creation
    #[prost(enumeration = "backup::BackupMethod", tag = "8")]
    pub method: i32,
    /// Size of the journal associated with backup, in bytes
    #[prost(int64, tag = "9")]
    pub journal_size: i64,
    /// Status of backup
    #[prost(enumeration = "backup::BackupStatus", tag = "10")]
    pub status: 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 BackupMethod {
        Unspecified = 0,
        /// Base backup
        Base = 1,
        /// Delta (incremental) PostgreSQL backup
        Incremental = 2,
    }
    impl BackupMethod {
        /// 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 {
                BackupMethod::Unspecified => "BACKUP_METHOD_UNSPECIFIED",
                BackupMethod::Base => "BASE",
                BackupMethod::Incremental => "INCREMENTAL",
            }
        }
        /// 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_METHOD_UNSPECIFIED" => Some(Self::Unspecified),
                "BASE" => Some(Self::Base),
                "INCREMENTAL" => Some(Self::Incremental),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum BackupCreationType {
        Unspecified = 0,
        /// Backup created by automated daily schedule
        Automated = 1,
        /// Backup created by user request
        Manual = 2,
    }
    impl BackupCreationType {
        /// 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 {
                BackupCreationType::Unspecified => "BACKUP_CREATION_TYPE_UNSPECIFIED",
                BackupCreationType::Automated => "AUTOMATED",
                BackupCreationType::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_CREATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "AUTOMATED" => Some(Self::Automated),
                "MANUAL" => Some(Self::Manual),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum BackupStatus {
        Unspecified = 0,
        /// Backup is done
        Done = 1,
        /// Backup is creating
        Creating = 2,
    }
    impl BackupStatus {
        /// 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 {
                BackupStatus::Unspecified => "BACKUP_STATUS_UNSPECIFIED",
                BackupStatus::Done => "DONE",
                BackupStatus::Creating => "CREATING",
            }
        }
        /// 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_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "DONE" => Some(Self::Done),
                "CREATING" => Some(Self::Creating),
                _ => None,
            }
        }
    }
}
/// Message to describe a crontab schedule.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CronTab {
    #[prost(string, tag = "3")]
    pub day_of_month: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub month: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub day_of_week: ::prost::alloc::string::String,
}
/// Message to describe a retention policy for cluster backups.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BackupRetentionPolicy {
    /// Required. Policy ID.
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
    /// PostgreSQL cluster ID.
    #[prost(string, tag = "2")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Required. Policy name.
    #[prost(string, tag = "3")]
    pub policy_name: ::prost::alloc::string::String,
    /// Creation timestamp in \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format.
    #[prost(message, optional, tag = "4")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// CronTab schedule.
    #[prost(message, optional, tag = "5")]
    pub cron: ::core::option::Option<CronTab>,
    /// Retention duration.
    #[prost(int64, tag = "6")]
    pub retain_for_days: i64,
    /// Human-readable description.
    #[prost(string, tag = "7")]
    pub description: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBackupRetentionPoliciesRequest {
    /// ID of the PostgreSQL cluster.
    /// To get the PostgreSQL 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 \[ListBackupRetentionPoliciesResponse.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 \[ListBackupRetentionPoliciesResponse.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 ListBackupRetentionPoliciesResponse {
    /// List of \[BackupRetentionPolicy\] associated with the cluster.
    #[prost(message, repeated, tag = "1")]
    pub policies: ::prost::alloc::vec::Vec<BackupRetentionPolicy>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListBackupRetentionPoliciesRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListBackupRetentionPoliciesRequest.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 CreateBackupRetentionPolicyRequest {
    /// ID of the PostgreSQL cluster.
    /// To get the PostgreSQL cluster ID use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// CronTab schedule.
    #[prost(message, optional, tag = "2")]
    pub cron: ::core::option::Option<CronTab>,
    /// Retention duration.
    #[prost(int64, tag = "3")]
    pub retain_for_days: i64,
    /// Policy description.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Required. Policy name.
    #[prost(string, tag = "5")]
    pub policy_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateBackupRetentionPolicyResponse {
    /// Newly created \[BackupRetentionPolicy\].
    #[prost(message, optional, tag = "1")]
    pub policy: ::core::option::Option<BackupRetentionPolicy>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteBackupRetentionPolicyRequest {
    /// Unique identifier for the \[BackupRetentionPolicy\].
    #[prost(string, tag = "1")]
    pub policy_id: ::prost::alloc::string::String,
    /// ID of the PostgreSQL cluster.
    /// To get the PostgreSQL cluster ID use a \[ClusterService.List\] request.
    #[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 DeleteBackupRetentionPolicyResponse {}
/// Generated client implementations.
pub mod backup_retention_policy_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 PostgreSQL Cluster backup retention policies.
    #[derive(Debug, Clone)]
    pub struct BackupRetentionPolicyServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl BackupRetentionPolicyServiceClient<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> BackupRetentionPolicyServiceClient<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,
        ) -> BackupRetentionPolicyServiceClient<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,
        {
            BackupRetentionPolicyServiceClient::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
        }
        /// List all retention policies.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListBackupRetentionPoliciesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListBackupRetentionPoliciesResponse>,
            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.postgresql.v1.BackupRetentionPolicyService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.BackupRetentionPolicyService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Add a new retention policy.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateBackupRetentionPolicyRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateBackupRetentionPolicyResponse>,
            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.postgresql.v1.BackupRetentionPolicyService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.BackupRetentionPolicyService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete retention policy.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteBackupRetentionPolicyRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteBackupRetentionPolicyResponse>,
            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.postgresql.v1.BackupRetentionPolicyService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.BackupRetentionPolicyService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[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 PostgreSQL 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 PostgreSQL backup that is currently being deleted.
    #[prost(string, tag = "1")]
    pub backup_id: ::prost::alloc::string::String,
    /// ID of the cluster which backup belonged to.
    #[prost(string, tag = "2")]
    pub cluster_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 PostgreSQL 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 PostgreSQL Backup resource.
        ///
        /// To get the list of available PostgreSQL Backup resources, 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.postgresql.v1.BackupService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.BackupService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of Backup resources 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.postgresql.v1.BackupService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.BackupService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified PostgreSQL cluster backup.
        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.postgresql.v1.BackupService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.BackupService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A maintenance window settings.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MaintenanceWindow {
    /// The maintenance policy in effect.
    #[prost(oneof = "maintenance_window::Policy", tags = "1, 2")]
    pub policy: ::core::option::Option<maintenance_window::Policy>,
}
/// Nested message and enum types in `MaintenanceWindow`.
pub mod maintenance_window {
    /// The maintenance policy in effect.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Policy {
        /// Maintenance operation can be scheduled anytime.
        #[prost(message, tag = "1")]
        Anytime(super::AnytimeMaintenanceWindow),
        /// Maintenance operation can be scheduled on a weekly basis.
        #[prost(message, tag = "2")]
        WeeklyMaintenanceWindow(super::WeeklyMaintenanceWindow),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AnytimeMaintenanceWindow {}
/// Weelky maintenance window settings.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WeeklyMaintenanceWindow {
    /// Day of the week (in `DDD` format).
    #[prost(enumeration = "weekly_maintenance_window::WeekDay", tag = "1")]
    pub day: i32,
    /// Hour of the day in UTC (in `HH` format).
    #[prost(int64, tag = "2")]
    pub hour: i64,
}
/// Nested message and enum types in `WeeklyMaintenanceWindow`.
pub mod weekly_maintenance_window {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum WeekDay {
        Unspecified = 0,
        Mon = 1,
        Tue = 2,
        Wed = 3,
        Thu = 4,
        Fri = 5,
        Sat = 6,
        Sun = 7,
    }
    impl WeekDay {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                WeekDay::Unspecified => "WEEK_DAY_UNSPECIFIED",
                WeekDay::Mon => "MON",
                WeekDay::Tue => "TUE",
                WeekDay::Wed => "WED",
                WeekDay::Thu => "THU",
                WeekDay::Fri => "FRI",
                WeekDay::Sat => "SAT",
                WeekDay::Sun => "SUN",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "WEEK_DAY_UNSPECIFIED" => Some(Self::Unspecified),
                "MON" => Some(Self::Mon),
                "TUE" => Some(Self::Tue),
                "WED" => Some(Self::Wed),
                "THU" => Some(Self::Thu),
                "FRI" => Some(Self::Fri),
                "SAT" => Some(Self::Sat),
                "SUN" => Some(Self::Sun),
                _ => None,
            }
        }
    }
}
/// A planned maintenance operation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MaintenanceOperation {
    /// Information about this maintenance operation.
    #[prost(string, tag = "1")]
    pub info: ::prost::alloc::string::String,
    /// Time until which this maintenance operation is delayed.
    #[prost(message, optional, tag = "2")]
    pub delayed_until: ::core::option::Option<::prost_types::Timestamp>,
}
/// A PostgreSQL Cluster resource. For more information, see
/// the \[Concepts\](/docs/managed-postgresql/concepts) section of the documentation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Cluster {
    /// ID of the PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL cluster. 0-256 characters long.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the PostgreSQL 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 PostgreSQL cluster.
    #[prost(enumeration = "cluster::Environment", tag = "7")]
    pub environment: i32,
    /// Description of monitoring systems relevant to the PostgreSQL cluster.
    #[prost(message, repeated, tag = "8")]
    pub monitoring: ::prost::alloc::vec::Vec<Monitoring>,
    /// Configuration of the PostgreSQL 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,
    /// Maintenance window for the cluster.
    #[prost(message, optional, tag = "13")]
    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 = "14")]
    pub planned_operation: ::core::option::Option<MaintenanceOperation>,
    /// User security groups
    #[prost(string, repeated, tag = "15")]
    pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Deletion Protection inhibits deletion of the cluster
    #[prost(bool, tag = "16")]
    pub deletion_protection: bool,
    /// Host groups hosting VMs of the cluster.
    #[prost(string, repeated, tag = "17")]
    pub host_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Nested message and enum types in `Cluster`.
pub mod cluster {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Environment {
        Unspecified = 0,
        /// Stable environment with a conservative update policy:
        /// only hotfixes are applied during regular maintenance.
        Production = 1,
        /// Environment with more aggressive update policy: new versions
        /// are rolled out irrespective of backward compatibility.
        Prestable = 2,
    }
    impl Environment {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Environment::Unspecified => "ENVIRONMENT_UNSPECIFIED",
                Environment::Production => "PRODUCTION",
                Environment::Prestable => "PRESTABLE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ENVIRONMENT_UNSPECIFIED" => Some(Self::Unspecified),
                "PRODUCTION" => Some(Self::Production),
                "PRESTABLE" => Some(Self::Prestable),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Health {
        /// 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 PostgreSQL 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 PostgreSQL server software.
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    /// Configuration of the connection pooler.
    #[prost(message, optional, tag = "4")]
    pub pooler_config: ::core::option::Option<ConnectionPoolerConfig>,
    /// Resources allocated to PostgreSQL hosts.
    #[prost(message, optional, tag = "5")]
    pub resources: ::core::option::Option<Resources>,
    /// Configuration setting which enables/disables autofailover in cluster.
    #[prost(message, optional, tag = "6")]
    pub autofailover: ::core::option::Option<bool>,
    /// Time to start the daily backup, in the UTC timezone.
    #[prost(message, optional, tag = "7")]
    pub backup_window_start: ::core::option::Option<
        super::super::super::super::super::google::r#type::TimeOfDay,
    >,
    /// Retention policy of automated backups.
    #[prost(message, optional, tag = "17")]
    pub backup_retain_period_days: ::core::option::Option<i64>,
    /// Access policy to DB
    #[prost(message, optional, tag = "9")]
    pub access: ::core::option::Option<Access>,
    /// Configuration of the performance diagnostics service.
    #[prost(message, optional, tag = "12")]
    pub performance_diagnostics: ::core::option::Option<PerformanceDiagnostics>,
    /// Disk size autoscaling
    #[prost(message, optional, tag = "23")]
    pub disk_size_autoscaling: ::core::option::Option<DiskSizeAutoscaling>,
    /// Configuration for PostgreSQL servers in the cluster.
    #[prost(
        oneof = "cluster_config::PostgresqlConfig",
        tags = "2, 10, 3, 8, 13, 11, 14, 15, 18, 16, 19, 21, 22, 24, 25, 27, 28"
    )]
    pub postgresql_config: ::core::option::Option<cluster_config::PostgresqlConfig>,
}
/// Nested message and enum types in `ClusterConfig`.
pub mod cluster_config {
    /// Configuration for PostgreSQL servers in the cluster.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum PostgresqlConfig {
        /// Configuration of a PostgreSQL 9.6 server.
        #[prost(message, tag = "2")]
        PostgresqlConfig96(super::config::PostgresqlConfigSet96),
        /// Configuration of a PostgreSQL 10 1C server.
        #[prost(message, tag = "10")]
        PostgresqlConfig101c(super::config::PostgresqlConfigSet101c),
        /// Configuration of a PostgreSQL 10 server.
        #[prost(message, tag = "3")]
        PostgresqlConfig10(super::config::PostgresqlConfigSet10),
        /// Configuration of a PostgreSQL 11 server.
        #[prost(message, tag = "8")]
        PostgresqlConfig11(super::config::PostgresqlConfigSet11),
        /// Configuration of a PostgreSQL 11 1C server.
        #[prost(message, tag = "13")]
        PostgresqlConfig111c(super::config::PostgresqlConfigSet111c),
        /// Configuration of a PostgreSQL 12 server.
        #[prost(message, tag = "11")]
        PostgresqlConfig12(super::config::PostgresqlConfigSet12),
        /// Configuration of a PostgreSQL 12 1C server.
        #[prost(message, tag = "14")]
        PostgresqlConfig121c(super::config::PostgresqlConfigSet121c),
        /// Configuration of a PostgreSQL 13 server.
        #[prost(message, tag = "15")]
        PostgresqlConfig13(super::config::PostgresqlConfigSet13),
        /// Configuration of a PostgreSQL 13 1C server.
        #[prost(message, tag = "18")]
        PostgresqlConfig131c(super::config::PostgresqlConfigSet131c),
        /// Configuration of a PostgreSQL 14 server.
        #[prost(message, tag = "16")]
        PostgresqlConfig14(super::config::PostgresqlConfigSet14),
        /// Configuration of a PostgreSQL 14 1C server.
        #[prost(message, tag = "19")]
        PostgresqlConfig141c(super::config::PostgresqlConfigSet141c),
        /// Configuration of a PostgreSQL 15 server.
        #[prost(message, tag = "21")]
        PostgresqlConfig15(super::config::PostgresqlConfigSet15),
        /// Configuration of a PostgreSQL 15 1C server.
        #[prost(message, tag = "22")]
        PostgresqlConfig151c(super::config::PostgresqlConfigSet151c),
        /// Configuration of a PostgreSQL 16 server.
        #[prost(message, tag = "24")]
        PostgresqlConfig16(super::config::PostgresqlConfigSet16),
        /// Configuration of a PostgreSQL 16 1C server.
        #[prost(message, tag = "25")]
        PostgresqlConfig161c(super::config::PostgresqlConfigSet161c),
        /// Configuration of a PostgreSQL 17 server.
        #[prost(message, tag = "27")]
        PostgresqlConfig17(super::config::PostgresqlConfigSet17),
        /// Configuration of a PostgreSQL 17 1C server.
        #[prost(message, tag = "28")]
        PostgresqlConfig171c(super::config::PostgresqlConfigSet171c),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectionPoolerConfig {
    /// Mode that the connection pooler is working in.
    /// See descriptions of all modes in the [documentation for PgBouncer](<https://pgbouncer.github.io/usage>).
    #[prost(enumeration = "connection_pooler_config::PoolingMode", tag = "1")]
    pub pooling_mode: i32,
    /// Setting `server_reset_query_always` parameter in PgBouncer.
    #[prost(message, optional, tag = "2")]
    pub pool_discard: ::core::option::Option<bool>,
}
/// Nested message and enum types in `ConnectionPoolerConfig`.
pub mod connection_pooler_config {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum PoolingMode {
        Unspecified = 0,
        /// Session pooling mode.
        Session = 1,
        /// Transaction pooling mode.
        Transaction = 2,
        /// Statement pooling mode.
        Statement = 3,
    }
    impl PoolingMode {
        /// 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 {
                PoolingMode::Unspecified => "POOLING_MODE_UNSPECIFIED",
                PoolingMode::Session => "SESSION",
                PoolingMode::Transaction => "TRANSACTION",
                PoolingMode::Statement => "STATEMENT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "POOLING_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "SESSION" => Some(Self::Session),
                "TRANSACTION" => Some(Self::Transaction),
                "STATEMENT" => Some(Self::Statement),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Host {
    /// Name of the PostgreSQL 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 PostgreSQL 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 PostgreSQL host resides.
    #[prost(string, tag = "3")]
    pub zone_id: ::prost::alloc::string::String,
    /// Resources allocated to the PostgreSQL host.
    #[prost(message, optional, tag = "4")]
    pub resources: ::core::option::Option<Resources>,
    /// Role of the host in the cluster. If the field has default value, it is not returned in the response.
    #[prost(enumeration = "host::Role", tag = "5")]
    pub role: i32,
    /// Aggregated health of the host. If the field has default value, it is not returned in the response.
    #[prost(enumeration = "host::Health", tag = "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,
    /// Name of the host to be used as the replication source for cascading replication.
    #[prost(string, tag = "9")]
    pub replication_source: ::prost::alloc::string::String,
    /// Priority of the host as a replica. Higher value means higher priority.
    ///
    /// The host with the highest priority is the synchronous replica. All others are asynchronous.
    /// The synchronous replica replaces the master when needed.
    ///
    /// When a replica becomes the master, its priority is ignored.
    #[prost(message, optional, tag = "10")]
    pub priority: ::core::option::Option<i64>,
    /// Configuration of a PostgreSQL server for the host.
    #[prost(message, optional, tag = "11")]
    pub config: ::core::option::Option<HostConfig>,
    /// Flag showing public IP assignment status to this host.
    #[prost(bool, tag = "12")]
    pub assign_public_ip: bool,
    #[prost(enumeration = "host::ReplicaType", tag = "13")]
    pub replica_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 Role {
        /// Role of the host in the cluster is unknown. Default value.
        Unknown = 0,
        /// Host is the master PostgreSQL server in the cluster.
        Master = 1,
        /// Host is a replica (standby) PostgreSQL server in the cluster.
        Replica = 2,
    }
    impl Role {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Role::Unknown => "ROLE_UNKNOWN",
                Role::Master => "MASTER",
                Role::Replica => "REPLICA",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ROLE_UNKNOWN" => Some(Self::Unknown),
                "MASTER" => Some(Self::Master),
                "REPLICA" => Some(Self::Replica),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ReplicaType {
        /// Replica type is unknown (we have no data) or it's master
        Unknown = 0,
        Async = 1,
        Sync = 2,
        Quorum = 3,
    }
    impl ReplicaType {
        /// 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 {
                ReplicaType::Unknown => "REPLICA_TYPE_UNKNOWN",
                ReplicaType::Async => "ASYNC",
                ReplicaType::Sync => "SYNC",
                ReplicaType::Quorum => "QUORUM",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "REPLICA_TYPE_UNKNOWN" => Some(Self::Unknown),
                "ASYNC" => Some(Self::Async),
                "SYNC" => Some(Self::Sync),
                "QUORUM" => Some(Self::Quorum),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Health {
        /// Health of the host is unknown. Default value.
        Unknown = 0,
        /// The host is performing all its functions normally.
        Alive = 1,
        /// The host is inoperable, and cannot perform any of its essential functions.
        Dead = 2,
        /// The host is degraded, and can perform only some of its essential functions.
        Degraded = 3,
        /// The host is alive, but in read-only mode.
        Readonly = 4,
    }
    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",
                Health::Readonly => "READONLY",
            }
        }
        /// 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),
                "READONLY" => Some(Self::Readonly),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HostConfig {
    /// Configuration of a PostgreSQL server for the host.
    #[prost(
        oneof = "host_config::PostgresqlConfig",
        tags = "1, 4, 2, 3, 6, 5, 7, 8, 10, 9, 11, 12, 13, 14, 15, 16, 17"
    )]
    pub postgresql_config: ::core::option::Option<host_config::PostgresqlConfig>,
}
/// Nested message and enum types in `HostConfig`.
pub mod host_config {
    /// Configuration of a PostgreSQL server for the host.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum PostgresqlConfig {
        /// Configuration for a host with PostgreSQL 9.6 server deployed.
        #[prost(message, tag = "1")]
        PostgresqlConfig96(super::config::PostgresqlHostConfig96),
        /// Configuration for a host with PostgreSQL 10 1C server deployed.
        #[prost(message, tag = "4")]
        PostgresqlConfig101c(super::config::PostgresqlHostConfig101c),
        /// Configuration for a host with PostgreSQL 10 server deployed.
        #[prost(message, tag = "2")]
        PostgresqlConfig10(super::config::PostgresqlHostConfig10),
        /// Configuration for a host with PostgreSQL 11 server deployed.
        #[prost(message, tag = "3")]
        PostgresqlConfig11(super::config::PostgresqlHostConfig11),
        /// Configuration for a host with PostgreSQL 11 1C server deployed.
        #[prost(message, tag = "6")]
        PostgresqlConfig111c(super::config::PostgresqlHostConfig111c),
        /// Configuration for a host with PostgreSQL 12 server deployed.
        #[prost(message, tag = "5")]
        PostgresqlConfig12(super::config::PostgresqlHostConfig12),
        /// Configuration for a host with PostgreSQL 12 1C server deployed.
        #[prost(message, tag = "7")]
        PostgresqlConfig121c(super::config::PostgresqlHostConfig121c),
        /// Configuration for a host with PostgreSQL 13 server deployed.
        #[prost(message, tag = "8")]
        PostgresqlConfig13(super::config::PostgresqlHostConfig13),
        /// Configuration for a host with PostgreSQL 13 1C server deployed.
        #[prost(message, tag = "10")]
        PostgresqlConfig131c(super::config::PostgresqlHostConfig131c),
        /// Configuration for a host with PostgreSQL 14 server deployed.
        #[prost(message, tag = "9")]
        PostgresqlConfig14(super::config::PostgresqlHostConfig14),
        /// Configuration for a host with PostgreSQL 14 1C server deployed.
        #[prost(message, tag = "11")]
        PostgresqlConfig141c(super::config::PostgresqlHostConfig141c),
        /// Configuration for a host with PostgreSQL 15 server deployed.
        #[prost(message, tag = "12")]
        PostgresqlConfig15(super::config::PostgresqlHostConfig15),
        /// Configuration for a host with PostgreSQL 15 1C server deployed.
        #[prost(message, tag = "13")]
        PostgresqlConfig151c(super::config::PostgresqlHostConfig151c),
        /// Configuration for a host with PostgreSQL 16 server deployed.
        #[prost(message, tag = "14")]
        PostgresqlConfig16(super::config::PostgresqlHostConfig16),
        /// Configuration for a host with PostgreSQL 16 1C server deployed.
        #[prost(message, tag = "15")]
        PostgresqlConfig161c(super::config::PostgresqlHostConfig161c),
        /// Configuration for a host with PostgreSQL 17 server deployed.
        #[prost(message, tag = "16")]
        PostgresqlConfig17(super::config::PostgresqlHostConfig17),
        /// Configuration for a host with PostgreSQL 17 1C server deployed.
        #[prost(message, tag = "17")]
        PostgresqlConfig171c(super::config::PostgresqlHostConfig171c),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Service {
    /// Type of the service provided by the host. If the field has default value, it is not returned in the response.
    #[prost(enumeration = "service::Type", tag = "1")]
    pub r#type: i32,
    /// Aggregated health of the service. If the field has default value, it is not returned in the response.
    #[prost(enumeration = "service::Health", tag = "2")]
    pub health: i32,
}
/// Nested message and enum types in `Service`.
pub mod service {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        /// Service type of the host is unspecified. Default value.
        Unspecified = 0,
        /// The host is a PostgreSQL server.
        Postgresql = 1,
        /// The host is a PgBouncer server.
        Pooler = 2,
    }
    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::Postgresql => "POSTGRESQL",
                Type::Pooler => "POOLER",
            }
        }
        /// 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),
                "POSTGRESQL" => Some(Self::Postgresql),
                "POOLER" => Some(Self::Pooler),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Health {
        /// Health of the server is unknown. Default value.
        Unknown = 0,
        /// The server is working normally.
        Alive = 1,
        /// The server is dead or unresponsive.
        Dead = 2,
        /// The server is in read-only mode.
        Readonly = 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::Readonly => "READONLY",
            }
        }
        /// 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),
                "READONLY" => Some(Self::Readonly),
                _ => 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-postgresql/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 SQL queries to the cluster databases from the management console.
    ///
    /// See [SQL queries in the management console](/docs/managed-postgresql/operations/web-sql-query) for more details.
    #[prost(bool, tag = "2")]
    pub web_sql: bool,
    /// Allow access for Serverless
    #[prost(bool, tag = "3")]
    pub serverless: bool,
    /// Allow access for DataTransfer.
    #[prost(bool, tag = "4")]
    pub data_transfer: bool,
    /// Allow access for YandexQuery.
    #[prost(bool, tag = "5")]
    pub yandex_query: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PerformanceDiagnostics {
    /// Configuration setting which enables/disables performance diagnostics service in cluster.
    #[prost(bool, tag = "1")]
    pub enabled: bool,
    /// Interval (in seconds) for pg_stat_activity sampling
    #[prost(int64, tag = "2")]
    pub sessions_sampling_interval: i64,
    /// Interval (in seconds) for pg_stat_statements sampling
    #[prost(int64, tag = "3")]
    pub statements_sampling_interval: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DiskSizeAutoscaling {
    /// Threshold of storage usage (in percent) that triggers automatic scaling of the storage during the maintenance window. Zero value means disabled threshold.
    #[prost(int64, tag = "1")]
    pub planned_usage_threshold: i64,
    /// Threshold of storage usage (in percent) that triggers immediate automatic scaling of the storage. Zero value means disabled threshold.
    #[prost(int64, tag = "2")]
    pub emergency_usage_threshold: i64,
    /// New storage size (in bytes) that is set when one of the thresholds is achieved.
    #[prost(int64, tag = "3")]
    pub disk_size_limit: i64,
}
/// A PostgreSQL Database resource. For more information, see
/// the [Developer's Guide](/docs/managed-postgresql/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 PostgreSQL cluster that the database belongs to.
    #[prost(string, tag = "2")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the user assigned as the owner of the database.
    #[prost(string, tag = "3")]
    pub owner: ::prost::alloc::string::String,
    /// POSIX locale for string sorting order.
    /// Can only be set at creation time.
    #[prost(string, tag = "4")]
    pub lc_collate: ::prost::alloc::string::String,
    /// POSIX locale for character classification.
    /// Can only be set at creation time.
    #[prost(string, tag = "5")]
    pub lc_ctype: ::prost::alloc::string::String,
    /// PostgreSQL extensions enabled for the database.
    #[prost(message, repeated, tag = "6")]
    pub extensions: ::prost::alloc::vec::Vec<Extension>,
    /// Name of the database template.
    #[prost(string, tag = "7")]
    pub template_db: ::prost::alloc::string::String,
    /// Deletion Protection inhibits deletion of the database
    ///
    /// Default value: `unspecified` (inherits cluster's deletion_protection)
    #[prost(message, optional, tag = "8")]
    pub deletion_protection: ::core::option::Option<bool>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Extension {
    /// Name of the extension, e.g. `pg_trgm` or `pg_btree`.
    /// Extensions supported by Managed Service for PostgreSQL are [listed in the Developer's Guide](/docs/managed-postgresql/operations/extensions/cluster-extensions).
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Version of the extension.
    #[prost(string, tag = "2")]
    pub version: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatabaseSpec {
    /// Name of the PostgreSQL database. 1-63 characters long.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Name of the user to be assigned as the owner of the database.
    /// To get the list of available PostgreSQL users, make a \[UserService.List\] request.
    #[prost(string, tag = "2")]
    pub owner: ::prost::alloc::string::String,
    /// POSIX locale for string sorting order.
    /// Can only be set at creation time.
    #[prost(string, tag = "3")]
    pub lc_collate: ::prost::alloc::string::String,
    /// POSIX locale for character classification.
    /// Can only be set at creation time.
    #[prost(string, tag = "4")]
    pub lc_ctype: ::prost::alloc::string::String,
    /// PostgreSQL extensions to be enabled for the database.
    #[prost(message, repeated, tag = "5")]
    pub extensions: ::prost::alloc::vec::Vec<Extension>,
    /// Name of the PostgreSQL database template.
    #[prost(string, tag = "6")]
    pub template_db: ::prost::alloc::string::String,
    /// Deletion Protection inhibits deletion of the database
    ///
    /// Default value: `unspecified` (inherits cluster's deletion_protection)
    #[prost(message, optional, tag = "7")]
    pub deletion_protection: ::core::option::Option<bool>,
}
/// A PostgreSQL User resource. For more information, see
/// the [Developer's Guide](/docs/managed-postgresql/concepts).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct User {
    /// Name of the PostgreSQL user.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// ID of the PostgreSQL cluster the user belongs to.
    #[prost(string, tag = "2")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Set of permissions granted to the user to access specific databases.
    #[prost(message, repeated, tag = "3")]
    pub permissions: ::prost::alloc::vec::Vec<Permission>,
    /// Maximum number of database connections available to the user.
    ///
    /// When used in session pooling, this setting limits the number of connections to every single host in PostgreSQL cluster. In this case, the setting's value must be greater than the total number of connections that backend services can open to access the PostgreSQL cluster. The setting's value should not exceed the value of the \[Cluster.config.postgresql_config_12.effective_config.max_connections\] setting.
    ///
    /// When used in transaction pooling, this setting limits the number of user's active transactions; therefore, in this mode user can open thousands of connections, but only `N` concurrent connections will be opened, where `N` is the value of the setting.
    ///
    /// Minimum value: `10` (default: `50`), when used in session pooling.
    #[prost(int64, tag = "4")]
    pub conn_limit: i64,
    #[prost(message, optional, tag = "5")]
    pub settings: ::core::option::Option<UserSettings>,
    /// This flag defines whether the user can login to a PostgreSQL database.
    ///
    /// Default value: `true` (login is allowed).
    #[prost(message, optional, tag = "6")]
    pub login: ::core::option::Option<bool>,
    /// A set of roles and privileges that are granted to the user.
    ///
    /// For more information, see [the documentation](/docs/managed-postgresql/operations/grant).
    #[prost(string, repeated, tag = "7")]
    pub grants: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Determines whether the user deletion protection is enabled.
    ///
    /// The default value is `unspecified`. In this case, the user configuration inherits the cluster's deletion protection settings.
    #[prost(message, optional, tag = "8")]
    pub deletion_protection: ::core::option::Option<bool>,
    /// Password-based authentication method for user.
    /// Possible values are `` USER_PASSWORD_ENCRYPTION_MD5 `` or `` USER_PASSWORD_ENCRYPTION_SCRAM_SHA_256 ``.
    /// The default is `` password_encryption `` setting for cluster.
    #[prost(enumeration = "UserPasswordEncryption", tag = "9")]
    pub user_password_encryption: i32,
    /// Connection Manager Connection and settings associated with user. Read only field.
    #[prost(message, optional, tag = "10")]
    pub connection_manager: ::core::option::Option<ConnectionManager>,
}
#[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,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectionManager {
    /// ID of Connection Manager Connection
    #[prost(string, tag = "1")]
    pub connection_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UserSpec {
    /// Name of the PostgreSQL user.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Password of the PostgreSQL user.
    #[prost(string, tag = "2")]
    pub password: ::prost::alloc::string::String,
    /// Set of permissions to grant to the user to access specific databases.
    #[prost(message, repeated, tag = "3")]
    pub permissions: ::prost::alloc::vec::Vec<Permission>,
    /// Maximum number of database connections that should be available to the user.
    ///
    /// When used in session pooling, this setting limits the number of connections to every single host in PostgreSQL cluster. In this case, the setting's value must be greater than the total number of connections that backend services can open to access the PostgreSQL cluster. The setting's value should not exceed the value of the \[Cluster.config.postgresql_config_12.effective_config.max_connections\] setting.
    ///
    /// When used in transaction pooling, this setting limits the number of user's active transactions; therefore, in this mode user can open thousands of connections, but only `N` concurrent connections will be opened, where `N` is the value of the setting.
    ///
    /// Minimum value: `10` (default: `50`), when used in session pooling.
    #[prost(message, optional, tag = "4")]
    pub conn_limit: ::core::option::Option<i64>,
    /// PostgreSQL settings for the user.
    #[prost(message, optional, tag = "5")]
    pub settings: ::core::option::Option<UserSettings>,
    /// This flag defines whether the user can login to a PostgreSQL database.
    ///
    /// Default value: `true` (login is allowed).
    #[prost(message, optional, tag = "6")]
    pub login: ::core::option::Option<bool>,
    /// A set of roles and privileges that are granted to the user.
    ///
    /// For more information, see [the documentation](/docs/managed-postgresql/operations/grant).
    #[prost(string, repeated, tag = "7")]
    pub grants: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Deletion Protection inhibits deletion of the user
    ///
    /// Default value: `unspecified` (inherits cluster's deletion_protection)
    #[prost(message, optional, tag = "8")]
    pub deletion_protection: ::core::option::Option<bool>,
    /// Password-based authentication method for user.
    /// Possible values are `` USER_PASSWORD_ENCRYPTION_MD5 `` or `` USER_PASSWORD_ENCRYPTION_SCRAM_SHA_256 ``.
    /// The default is `` password_encryption `` setting for cluster.
    #[prost(enumeration = "UserPasswordEncryption", tag = "9")]
    pub user_password_encryption: i32,
    /// Generate password using Connection Manager.
    #[prost(message, optional, tag = "10")]
    pub generate_password: ::core::option::Option<bool>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PgAuditSettings {
    /// Defines which user queries will be written to the audit log. Corresponds to the [Pg audit log](<https://yandex.cloud/en/docs/managed-postgresql/concepts/settings-list#setting-pg-audit-log>) user setting.
    ///
    /// The possible values are the following:
    ///
    /// * PG_AUDIT_SETTINGS_LOG_READ: `SELECT` and `COPY` queries are logged if the data source is a relation or query.
    /// * PG_AUDIT_SETTINGS_LOG_WRITE: `INSERT`, `UPDATE`, `DELETE`, `TRUNCATE`, and `COPY` queries are logged if the data target is a relation.
    /// * PG_AUDIT_SETTINGS_LOG_FUNCTION: Function invocations and `DO` sections are logged.
    /// * PG_AUDIT_SETTINGS_LOG_ROLE: Statements related to role and privilege management, such as `GRANT`, `REVOKE`, or `CREATE/ALTER/DROP ROLE`, are logged.
    /// * PG_AUDIT_SETTINGS_LOG_DDL: Any `DDL` statements that do not belong to the `ROLE` class are logged.
    /// * PG_AUDIT_SETTINGS_LOG_MISC: Miscellaneous commands, such as `DISCARD`, `FETCH`, `CHECKPOINT`, `VACUUM`, and `SET`, are logged.
    /// * PG_AUDIT_SETTINGS_LOG_MISC_SET: Miscellaneous `SET` commands, e.g., `SET ROLE`, are logged.
    ///
    /// The default value is PG_AUDIT_SETTINGS_LOG_UNSPECIFIED. In this case, the parameter is not configured.
    #[prost(enumeration = "pg_audit_settings::PgAuditSettingsLog", repeated, tag = "1")]
    pub log: ::prost::alloc::vec::Vec<i32>,
}
/// Nested message and enum types in `PGAuditSettings`.
pub mod pg_audit_settings {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum PgAuditSettingsLog {
        Unspecified = 0,
        Read = 1,
        Write = 2,
        Function = 3,
        Role = 4,
        Ddl = 5,
        Misc = 6,
        MiscSet = 7,
    }
    impl PgAuditSettingsLog {
        /// 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 {
                PgAuditSettingsLog::Unspecified => "PG_AUDIT_SETTINGS_LOG_UNSPECIFIED",
                PgAuditSettingsLog::Read => "PG_AUDIT_SETTINGS_LOG_READ",
                PgAuditSettingsLog::Write => "PG_AUDIT_SETTINGS_LOG_WRITE",
                PgAuditSettingsLog::Function => "PG_AUDIT_SETTINGS_LOG_FUNCTION",
                PgAuditSettingsLog::Role => "PG_AUDIT_SETTINGS_LOG_ROLE",
                PgAuditSettingsLog::Ddl => "PG_AUDIT_SETTINGS_LOG_DDL",
                PgAuditSettingsLog::Misc => "PG_AUDIT_SETTINGS_LOG_MISC",
                PgAuditSettingsLog::MiscSet => "PG_AUDIT_SETTINGS_LOG_MISC_SET",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PG_AUDIT_SETTINGS_LOG_UNSPECIFIED" => Some(Self::Unspecified),
                "PG_AUDIT_SETTINGS_LOG_READ" => Some(Self::Read),
                "PG_AUDIT_SETTINGS_LOG_WRITE" => Some(Self::Write),
                "PG_AUDIT_SETTINGS_LOG_FUNCTION" => Some(Self::Function),
                "PG_AUDIT_SETTINGS_LOG_ROLE" => Some(Self::Role),
                "PG_AUDIT_SETTINGS_LOG_DDL" => Some(Self::Ddl),
                "PG_AUDIT_SETTINGS_LOG_MISC" => Some(Self::Misc),
                "PG_AUDIT_SETTINGS_LOG_MISC_SET" => Some(Self::MiscSet),
                _ => None,
            }
        }
    }
}
/// PostgreSQL user settings.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UserSettings {
    /// SQL sets an isolation level for each transaction.
    /// This setting defines the default isolation level to be set for all new SQL transactions.
    ///
    /// For more information, see the [PostgreSQL documentation](<https://www.postgresql.org/docs/current/transaction-iso.html>).
    #[prost(enumeration = "user_settings::TransactionIsolation", tag = "1")]
    pub default_transaction_isolation: i32,
    /// The maximum time (in milliseconds) for any statement to wait for acquiring a lock on an table, index, row or other database object.
    /// If the wait time is longer than the specified amount, then this statement is aborted.
    ///
    /// Default value: `0` (no control is enforced, a statement waiting time is unlimited).
    #[prost(message, optional, tag = "2")]
    pub lock_timeout: ::core::option::Option<i64>,
    /// This setting controls logging of the duration of statements.
    ///
    /// The duration of each completed statement will be logged if the statement ran for at least the specified amount of time (in milliseconds).
    /// E.g., if this setting's value is set to `500`, a statement that took 300 milliseconds to complete will not be logged; on the other hand, the one that took 2000 milliseconds to complete, will be logged.
    ///
    /// Value of `0` forces PostgreSQL to log the duration of all statements.
    ///
    /// Value of `-1` (default) disables logging of the duration of statements.
    ///
    /// For more information, see the [PostgreSQL documentation](<https://www.postgresql.org/docs/current/runtime-config-logging.html>).
    #[prost(message, optional, tag = "3")]
    pub log_min_duration_statement: ::core::option::Option<i64>,
    /// This setting defines whether DBMS will commit transaction in a synchronous way.
    ///
    /// When synchronization is enabled, cluster waits for the synchronous operations to be completed prior to reporting `success` to the client.
    /// These operations guarantee different levels of the data safety and visibility in the cluster.
    ///
    /// For more information, see the [PostgreSQL documentation](<https://www.postgresql.org/docs/current/runtime-config-wal.html#GUC-SYNCHRONOUS-COMMIT>).
    #[prost(enumeration = "user_settings::SynchronousCommit", tag = "4")]
    pub synchronous_commit: i32,
    /// The maximum storage space size (in kilobytes) that a single process can use to create temporary files.
    /// If a transaction exceeds this limit during execution, it will be aborted.
    ///
    /// A huge query may not fit into a server's RAM, therefore PostgreSQL will use some storage to store and execute such a query. Too big queries can make excessive use of the storage system, effectively making other quieries to run slow. This setting prevents execution of a big queries that can influence other queries by limiting size of temporary files.
    #[prost(message, optional, tag = "5")]
    pub temp_file_limit: ::core::option::Option<i64>,
    /// This setting specifies which SQL statements should be logged (on the user level).
    ///
    /// For more information, see the [PostgreSQL documentation](<https://www.postgresql.org/docs/current/runtime-config-logging.html>).
    #[prost(enumeration = "user_settings::LogStatement", tag = "6")]
    pub log_statement: i32,
    /// Mode that the connection pooler is working in with specified user.
    ///
    /// For more information, see the [Odyssey documentation](<https://github.com/yandex/odyssey/blob/master/documentation/configuration.md#pool-string>).
    #[prost(enumeration = "user_settings::PoolingMode", tag = "7")]
    pub pool_mode: i32,
    /// User can use prepared statements with transaction pooling.
    ///
    /// For more information, see the [PostgreSQL documentation](<https://www.postgresql.org/docs/current/sql-prepare.html>).
    #[prost(message, optional, tag = "8")]
    pub prepared_statements_pooling: ::core::option::Option<bool>,
    /// The connection pooler setting. It determines the maximum allowed replication lag (in seconds).
    /// Pooler will reject connections to the replica with a lag above this threshold.
    /// It can be useful to prevent application from reading stale data.
    ///
    /// Default value: 0
    ///
    /// Value of `0` disables this mechanism
    #[prost(message, optional, tag = "9")]
    pub catchup_timeout: ::core::option::Option<i64>,
    /// The maximum time (in milliseconds) to wait for WAL replication (can be set only for PostgreSQL 12+)
    /// Terminate replication connections that are inactive for longer than this amount of time.
    ///
    /// Default value: `60000` (60 seconds).
    ///
    /// Value of `0` disables the timeout mechanism.
    ///
    /// For more information, see the [PostgreSQL documentation](<https://www.postgresql.org/docs/current/runtime-config-replication.html>).
    #[prost(message, optional, tag = "10")]
    pub wal_sender_timeout: ::core::option::Option<i64>,
    /// Sets the maximum allowed idle time, in milliseconds, between queries while in a transaction.
    ///
    /// The default value is `0`, which disables the timeout.
    ///
    /// For more information, see the [PostgreSQL documentation](<https://www.postgresql.org/docs/current/runtime-config-client.html>).
    ///
    /// in milliseconds.
    #[prost(message, optional, tag = "11")]
    pub idle_in_transaction_session_timeout: ::core::option::Option<i64>,
    /// The maximum time (in milliseconds) to wait for statement.
    /// The timeout is measured from the time a command arrives at the server until it is completed by the server.
    ///
    /// If `log_min_error_statement` is set to ERROR or lower, the statement that timed out will also be logged.
    ///
    /// Value of `0` (default) disables the timeout
    ///
    /// For more information, see the [PostgreSQL documentation](<https://www.postgresql.org/docs/current/runtime-config-client.html>).
    #[prost(message, optional, tag = "12")]
    pub statement_timeout: ::core::option::Option<i64>,
    /// Settings of the [PostgreSQL Audit Extension](<https://www.pgaudit.org/>) (pgaudit).
    #[prost(message, optional, tag = "13")]
    pub pgaudit: ::core::option::Option<PgAuditSettings>,
}
/// Nested message and enum types in `UserSettings`.
pub mod user_settings {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SynchronousCommit {
        Unspecified = 0,
        /// Success is reported to the client if the data is in WAL (Write-Ahead Log), and WAL is written to the storage of both the master and its synchronous standby server. Default value.
        On = 1,
        /// Success is reported to the client even if the data is not in WAL.
        /// There is no synchronous write operation, data may be loss in case of storage subsystem failure.
        Off = 2,
        /// Success is reported to the client if the data is in WAL, and WAL is written to the storage of the master server.
        /// The transaction may be lost due to storage subsystem failure on the master server.
        Local = 3,
        /// Success is reported to the client if the data is in WAL, WAL is written to the storage of the master server, and the server's synchronous standby indicates that it has received WAL and written it out to its operating system.
        /// The transaction may be lost due to simultaneous storage subsystem failure on the master and operating system's failure on the synchronous standby.
        RemoteWrite = 4,
        /// Success is reported to the client if the data is in WAL (Write-Ahead Log), WAL is written to the storage of the master server, and its synchronous standby indicates that it has received WAL and applied it.
        /// The transaction may be lost due to irrecoverably failure of both the master and its synchronous standby.
        RemoteApply = 5,
    }
    impl SynchronousCommit {
        /// 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 {
                SynchronousCommit::Unspecified => "SYNCHRONOUS_COMMIT_UNSPECIFIED",
                SynchronousCommit::On => "SYNCHRONOUS_COMMIT_ON",
                SynchronousCommit::Off => "SYNCHRONOUS_COMMIT_OFF",
                SynchronousCommit::Local => "SYNCHRONOUS_COMMIT_LOCAL",
                SynchronousCommit::RemoteWrite => "SYNCHRONOUS_COMMIT_REMOTE_WRITE",
                SynchronousCommit::RemoteApply => "SYNCHRONOUS_COMMIT_REMOTE_APPLY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SYNCHRONOUS_COMMIT_UNSPECIFIED" => Some(Self::Unspecified),
                "SYNCHRONOUS_COMMIT_ON" => Some(Self::On),
                "SYNCHRONOUS_COMMIT_OFF" => Some(Self::Off),
                "SYNCHRONOUS_COMMIT_LOCAL" => Some(Self::Local),
                "SYNCHRONOUS_COMMIT_REMOTE_WRITE" => Some(Self::RemoteWrite),
                "SYNCHRONOUS_COMMIT_REMOTE_APPLY" => Some(Self::RemoteApply),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum LogStatement {
        Unspecified = 0,
        /// Logs none of SQL statements. Default value.
        None = 1,
        /// Logs all data definition statements (such as `CREATE`, `ALTER`, `DROP` and others).
        Ddl = 2,
        /// Logs all statements that fall in the `LOG_STATEMENT_DDL` category plus data-modifying statements (such as `INSERT`, `UPDATE` and others).
        Mod = 3,
        /// Logs all SQL statements.
        All = 4,
    }
    impl LogStatement {
        /// 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 {
                LogStatement::Unspecified => "LOG_STATEMENT_UNSPECIFIED",
                LogStatement::None => "LOG_STATEMENT_NONE",
                LogStatement::Ddl => "LOG_STATEMENT_DDL",
                LogStatement::Mod => "LOG_STATEMENT_MOD",
                LogStatement::All => "LOG_STATEMENT_ALL",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "LOG_STATEMENT_UNSPECIFIED" => Some(Self::Unspecified),
                "LOG_STATEMENT_NONE" => Some(Self::None),
                "LOG_STATEMENT_DDL" => Some(Self::Ddl),
                "LOG_STATEMENT_MOD" => Some(Self::Mod),
                "LOG_STATEMENT_ALL" => Some(Self::All),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum TransactionIsolation {
        Unspecified = 0,
        /// This level behaves like `TRANSACTION_ISOLATION_READ_COMMITTED` in PostgreSQL.
        ReadUncommitted = 1,
        /// On this level query sees only data committed before the query began. Default value.
        ReadCommitted = 2,
        /// On this level all subsequent queries in a transaction will see the same rows, that were read by the first `SELECT` or `INSERT` query in this transaction, unchanged (these rows are locked during the first query).
        RepeatableRead = 3,
        /// This level provides the strictest transaction isolation.
        /// All queries in the current transaction see only the rows that were fixed prior to execution of the first `SELECT` or `INSERT` query in this transaction.
        /// If read and write operations in a concurrent set of serializable transactions overlap and this may cause an inconsistency that is not possible during the serial transaction execution, then one of the transaction will be rolled back, triggering a serialization failure.
        Serializable = 4,
    }
    impl TransactionIsolation {
        /// 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 {
                TransactionIsolation::Unspecified => "TRANSACTION_ISOLATION_UNSPECIFIED",
                TransactionIsolation::ReadUncommitted => {
                    "TRANSACTION_ISOLATION_READ_UNCOMMITTED"
                }
                TransactionIsolation::ReadCommitted => {
                    "TRANSACTION_ISOLATION_READ_COMMITTED"
                }
                TransactionIsolation::RepeatableRead => {
                    "TRANSACTION_ISOLATION_REPEATABLE_READ"
                }
                TransactionIsolation::Serializable => {
                    "TRANSACTION_ISOLATION_SERIALIZABLE"
                }
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TRANSACTION_ISOLATION_UNSPECIFIED" => Some(Self::Unspecified),
                "TRANSACTION_ISOLATION_READ_UNCOMMITTED" => Some(Self::ReadUncommitted),
                "TRANSACTION_ISOLATION_READ_COMMITTED" => Some(Self::ReadCommitted),
                "TRANSACTION_ISOLATION_REPEATABLE_READ" => Some(Self::RepeatableRead),
                "TRANSACTION_ISOLATION_SERIALIZABLE" => Some(Self::Serializable),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum PoolingMode {
        Unspecified = 0,
        /// Server connection will be assigned to it for the whole duration the client stays connected. Default value.
        Session = 1,
        /// Server connection is assigned to a client only during a transaction.
        Transaction = 2,
        /// Server connection will be put back into the pool immediately after a query completes.
        Statement = 3,
    }
    impl PoolingMode {
        /// 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 {
                PoolingMode::Unspecified => "POOLING_MODE_UNSPECIFIED",
                PoolingMode::Session => "SESSION",
                PoolingMode::Transaction => "TRANSACTION",
                PoolingMode::Statement => "STATEMENT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "POOLING_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "SESSION" => Some(Self::Session),
                "TRANSACTION" => Some(Self::Transaction),
                "STATEMENT" => Some(Self::Statement),
                _ => None,
            }
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum UserPasswordEncryption {
    Unspecified = 0,
    Md5 = 1,
    ScramSha256 = 2,
}
impl UserPasswordEncryption {
    /// 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 {
            UserPasswordEncryption::Unspecified => "USER_PASSWORD_ENCRYPTION_UNSPECIFIED",
            UserPasswordEncryption::Md5 => "USER_PASSWORD_ENCRYPTION_MD5",
            UserPasswordEncryption::ScramSha256 => {
                "USER_PASSWORD_ENCRYPTION_SCRAM_SHA_256"
            }
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "USER_PASSWORD_ENCRYPTION_UNSPECIFIED" => Some(Self::Unspecified),
            "USER_PASSWORD_ENCRYPTION_MD5" => Some(Self::Md5),
            "USER_PASSWORD_ENCRYPTION_SCRAM_SHA_256" => Some(Self::ScramSha256),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetClusterRequest {
    /// ID of the PostgreSQL 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 PostgreSQL clusters in.
    /// To get the folder ID, use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\], the service returns a \[ListClustersResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the \[ListClustersResponse.next_page_token\]
    /// returned by the previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters 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 PostgreSQL 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,
}
/// Message to describe a new retention policy for cluster backups.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BackupRetentionPolicySpec {
    /// Required. Policy name.
    #[prost(string, tag = "1")]
    pub policy_name: ::prost::alloc::string::String,
    /// CronTab schedule.
    #[prost(message, optional, tag = "2")]
    pub cron: ::core::option::Option<CronTab>,
    /// Retention duration.
    #[prost(int64, tag = "3")]
    pub retain_for_days: i64,
    /// Human-readable description.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateClusterRequest {
    /// ID of the folder to create the PostgreSQL cluster in.
    #[prost(string, tag = "1")]
    pub folder_id: ::prost::alloc::string::String,
    /// Name of the PostgreSQL cluster. The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the PostgreSQL cluster.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the PostgreSQL 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 PostgreSQL cluster.
    #[prost(enumeration = "cluster::Environment", tag = "5")]
    pub environment: i32,
    /// Configuration and resources for hosts that should be created for the PostgreSQL cluster.
    #[prost(message, optional, tag = "6")]
    pub config_spec: ::core::option::Option<ConfigSpec>,
    /// Descriptions of databases to be created in the PostgreSQL cluster.
    #[prost(message, repeated, tag = "7")]
    pub database_specs: ::prost::alloc::vec::Vec<DatabaseSpec>,
    /// Descriptions of database users to be created in the PostgreSQL cluster.
    #[prost(message, repeated, tag = "8")]
    pub user_specs: ::prost::alloc::vec::Vec<UserSpec>,
    /// Individual configurations for hosts that should be created for the PostgreSQL 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,
    /// Host groups hosting VMs of the cluster.
    #[prost(string, repeated, tag = "13")]
    pub host_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Window of maintenance operations.
    #[prost(message, optional, tag = "14")]
    pub maintenance_window: ::core::option::Option<MaintenanceWindow>,
    /// Backup long-term retention policies setting.
    #[prost(message, repeated, tag = "15")]
    pub retention_policies: ::prost::alloc::vec::Vec<BackupRetentionPolicySpec>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateClusterMetadata {
    /// ID of the PostgreSQL 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 PostgreSQL Cluster resource to update.
    /// To get the PostgreSQL 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 PostgreSQL Cluster resource should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New description of the PostgreSQL cluster.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the PostgreSQL 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,
    /// ID of the network to move the cluster to.
    #[prost(string, tag = "11")]
    pub network_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateClusterMetadata {
    /// ID of the PostgreSQL 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 PostgreSQL cluster to delete.
    /// To get the PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL cluster to back up.
    /// To get the PostgreSQL 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 PostgreSQL cluster that is being backed up.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the PostgreSQL backup that is being created.
    #[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 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,
    /// Timestamp of the moment to which the PostgreSQL cluster should be restored.
    #[prost(message, optional, tag = "2")]
    pub time: ::core::option::Option<::prost_types::Timestamp>,
    /// Flag that indicates whether a database should be restored to the first backup point
    /// available just after the timestamp specified in the \[time\] field instead of just before.
    ///
    /// Possible values:
    /// * false (default) - the restore point refers to the first backup moment before \[time\].
    /// * true - the restore point refers to the first backup point after \[time\].
    #[prost(bool, tag = "3")]
    pub time_inclusive: bool,
    /// Name of the new PostgreSQL cluster. The name must be unique within the folder.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the new PostgreSQL cluster.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the PostgreSQL cluster as `` key:value `` pairs. Maximum 64 per resource.
    /// For example, "project": "mvp" or "source": "dictionary".
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Deployment environment of the new PostgreSQL cluster.
    #[prost(enumeration = "cluster::Environment", tag = "7")]
    pub environment: i32,
    /// Configuration for the PostgreSQL cluster to be created.
    #[prost(message, optional, tag = "8")]
    pub config_spec: ::core::option::Option<ConfigSpec>,
    /// Configurations for PostgreSQL hosts that should be created for
    /// the cluster that is being created from the backup.
    #[prost(message, repeated, tag = "9")]
    pub host_specs: ::prost::alloc::vec::Vec<HostSpec>,
    /// ID of the network to create the PostgreSQL cluster in.
    #[prost(string, tag = "10")]
    pub network_id: ::prost::alloc::string::String,
    /// ID of the folder to create the PostgreSQL cluster in.
    #[prost(string, tag = "11")]
    pub folder_id: ::prost::alloc::string::String,
    /// User security groups
    #[prost(string, repeated, tag = "12")]
    pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Deletion Protection inhibits deletion of the cluster
    #[prost(bool, tag = "13")]
    pub deletion_protection: bool,
    /// Host groups hosting VMs of the cluster.
    #[prost(string, repeated, tag = "14")]
    pub host_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RestoreClusterMetadata {
    /// ID of the new PostgreSQL cluster that is being created from a backup.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the backup that is being used for creating a cluster.
    #[prost(string, tag = "2")]
    pub backup_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartClusterFailoverRequest {
    /// ID of PostgreSQL cluster.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// New master host. Switch to the most up-to-date replica if not provided.
    #[prost(string, tag = "2")]
    pub host_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartClusterFailoverMetadata {
    /// ID of the PostgreSQL cluster being failovered.
    #[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 RescheduleMaintenanceRequest {
    /// ID of the PostgreSQL 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 PostgreSQL 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 PostgreSQL cluster to request logs for.
    /// To get the PostgreSQL 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.
    #[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,
    /// Always return `next_page_token`, even if current page is empty.
    #[prost(bool, tag = "8")]
    pub always_next_page_token: bool,
}
/// 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 PostgreSQL activity.
        Postgresql = 1,
        /// Logs of connection pooler activity.
        Pooler = 2,
    }
    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::Postgresql => "POSTGRESQL",
                ServiceType::Pooler => "POOLER",
            }
        }
        /// 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),
                "POSTGRESQL" => Some(Self::Postgresql),
                "POOLER" => Some(Self::Pooler),
                _ => 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 PostgreSQL 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.error_severity\] (for POSTGRESQL service), \[LogRecord.logs.message.level\] (for POOLER service) 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.error_severity IN ("ERROR", "FATAL", "PANIC") AND message.hostname = "node1.db.cloud.yandex.net"`
    #[prost(string, tag = "7")]
    pub filter: ::prost::alloc::string::String,
}
/// Nested message and enum types in `StreamClusterLogsRequest`.
pub mod stream_cluster_logs_request {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ServiceType {
        Unspecified = 0,
        /// Logs of PostgreSQL activity.
        Postgresql = 1,
        /// Logs of connection pooler activity.
        Pooler = 2,
    }
    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::Postgresql => "POSTGRESQL",
                ServiceType::Pooler => "POOLER",
            }
        }
        /// 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),
                "POSTGRESQL" => Some(Self::Postgresql),
                "POOLER" => Some(Self::Pooler),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterOperationsRequest {
    /// ID of the PostgreSQL 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.
    #[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 PostgreSQL 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 PostgreSQL cluster.
    /// To get the PostgreSQL cluster ID use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\], the service returns a \[ListClusterBackupsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token.  To get the next page of results, set \[page_token\] to the \[ListClusterBackupsResponse.next_page_token\]
    /// returned by the previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterBackupsResponse {
    /// List of PostgreSQL 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 PostgreSQL cluster.
    /// To get the PostgreSQL cluster ID use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\], the service returns a \[ListClusterHostsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token.  To get the next page of results, set \[page_token\] to the \[ListClusterHostsResponse.next_page_token\]
    /// returned by the previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterHostsResponse {
    /// List of 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 PostgreSQL cluster to add hosts to.
    /// To get the PostgreSQL cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Configurations for PostgreSQL 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 PostgreSQL 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 PostgreSQL cluster to remove hosts from.
    /// To get the PostgreSQL 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 PostgreSQL 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 UpdateClusterHostsRequest {
    /// ID of the PostgreSQL cluster to update hosts in.
    /// To get the PostgreSQL cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// New configurations to apply to hosts.
    #[prost(message, repeated, tag = "2")]
    pub update_host_specs: ::prost::alloc::vec::Vec<UpdateHostSpec>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateClusterHostsMetadata {
    /// ID of the PostgreSQL cluster to update hosts in.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Names of hosts that are being updated.
    #[prost(string, repeated, tag = "2")]
    pub host_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateHostSpec {
    /// Name of the host to update.
    /// To get the PostgreSQL host name, use a \[ClusterService.ListHosts\] request.
    #[prost(string, tag = "1")]
    pub host_name: ::prost::alloc::string::String,
    /// \[Host.name\] of the host to be used as the replication source (for cascading replication).
    /// To get the PostgreSQL host name, use a \[ClusterService.ListHosts\] request.
    #[prost(string, tag = "2")]
    pub replication_source: ::prost::alloc::string::String,
    /// The host with the highest priority is the synchronous replica. All others are asynchronous.
    /// The synchronous replica replaces the master when needed.
    ///
    /// When a replica becomes the master, its priority is ignored.
    #[prost(message, optional, tag = "3")]
    pub priority: ::core::option::Option<i64>,
    /// Configuration of a PostgreSQL server for the host.
    #[prost(message, optional, tag = "4")]
    pub config_spec: ::core::option::Option<ConfigHostSpec>,
    /// Field mask that specifies which fields of the PostgreSQL host should be updated.
    #[prost(message, optional, tag = "5")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Whether the host should get a public IP address on creation.
    #[prost(bool, tag = "6")]
    pub assign_public_ip: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HostSpec {
    /// ID of the availability zone where the host resides.
    /// To get a list of available zones, use the \[yandex.cloud.compute.v1.ZoneService.List\] request.
    #[prost(string, tag = "1")]
    pub zone_id: ::prost::alloc::string::String,
    /// ID of the subnet that the host should belong to. This subnet should be a part
    /// of the network that the cluster belongs to.
    /// The ID of the network is set in the field \[Cluster.network_id\].
    #[prost(string, tag = "2")]
    pub subnet_id: ::prost::alloc::string::String,
    /// 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,
    /// \[Host.name\] of the host to be used as the replication source (for cascading replication).
    #[prost(string, tag = "4")]
    pub replication_source: ::prost::alloc::string::String,
    /// Priority of the host as a replica. A higher value corresponds to higher priority.
    ///
    /// The host with the highest priority is the synchronous replica. All others are asynchronous.
    /// The synchronous replica replaces the master when needed.
    ///
    /// When a replica becomes the master, its priority is ignored.
    #[prost(message, optional, tag = "5")]
    pub priority: ::core::option::Option<i64>,
    /// Configuration of a PostgreSQL server for the host.
    #[prost(message, optional, tag = "6")]
    pub config_spec: ::core::option::Option<ConfigHostSpec>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConfigSpec {
    /// Version of PostgreSQL used in the cluster.
    /// Possible values: `9.6`, `10`, `10_1c`, `11`, `12`, `13`, `14`, `15`, `16`, `17`
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    /// Configuration of the connection pooler.
    #[prost(message, optional, tag = "4")]
    pub pooler_config: ::core::option::Option<ConnectionPoolerConfig>,
    /// Resources allocated to PostgreSQL hosts.
    #[prost(message, optional, tag = "5")]
    pub resources: ::core::option::Option<Resources>,
    /// Configuration setting which enables/disables autofailover in cluster.
    #[prost(message, optional, tag = "6")]
    pub autofailover: ::core::option::Option<bool>,
    /// Time to start the daily backup, in the UTC timezone.
    #[prost(message, optional, tag = "8")]
    pub backup_window_start: ::core::option::Option<
        super::super::super::super::super::google::r#type::TimeOfDay,
    >,
    /// Retention policy of automated backups.
    #[prost(message, optional, tag = "17")]
    pub backup_retain_period_days: ::core::option::Option<i64>,
    /// Access policy to DB
    #[prost(message, optional, tag = "9")]
    pub access: ::core::option::Option<Access>,
    /// Configuration of the performance diagnostics service.
    #[prost(message, optional, tag = "12")]
    pub performance_diagnostics: ::core::option::Option<PerformanceDiagnostics>,
    /// Disk size autoscaling
    #[prost(message, optional, tag = "23")]
    pub disk_size_autoscaling: ::core::option::Option<DiskSizeAutoscaling>,
    /// Configuration of a PostgreSQL cluster.
    #[prost(
        oneof = "config_spec::PostgresqlConfig",
        tags = "2, 10, 3, 7, 13, 11, 14, 15, 18, 16, 19, 21, 22, 24, 25, 27, 28"
    )]
    pub postgresql_config: ::core::option::Option<config_spec::PostgresqlConfig>,
}
/// Nested message and enum types in `ConfigSpec`.
pub mod config_spec {
    /// Configuration of a PostgreSQL cluster.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum PostgresqlConfig {
        /// Configuration for a PostgreSQL 9.6 cluster.
        #[prost(message, tag = "2")]
        PostgresqlConfig96(super::config::PostgresqlConfig96),
        /// Configuration for a PostgreSQL 10 1C cluster.
        #[prost(message, tag = "10")]
        PostgresqlConfig101c(super::config::PostgresqlConfig101c),
        /// Configuration for a PostgreSQL 10 cluster.
        #[prost(message, tag = "3")]
        PostgresqlConfig10(super::config::PostgresqlConfig10),
        /// Configuration for a PostgreSQL 11 cluster.
        #[prost(message, tag = "7")]
        PostgresqlConfig11(super::config::PostgresqlConfig11),
        /// Configuration for a PostgreSQL 11 1C cluster.
        #[prost(message, tag = "13")]
        PostgresqlConfig111c(super::config::PostgresqlConfig111c),
        /// Configuration for a PostgreSQL 12 cluster.
        #[prost(message, tag = "11")]
        PostgresqlConfig12(super::config::PostgresqlConfig12),
        /// Configuration for a PostgreSQL 12 1C cluster.
        #[prost(message, tag = "14")]
        PostgresqlConfig121c(super::config::PostgresqlConfig121c),
        /// Configuration for a PostgreSQL 13 cluster.
        #[prost(message, tag = "15")]
        PostgresqlConfig13(super::config::PostgresqlConfig13),
        /// Configuration for a PostgreSQL 13 1C cluster.
        #[prost(message, tag = "18")]
        PostgresqlConfig131c(super::config::PostgresqlConfig131c),
        /// Configuration for a PostgreSQL 14 cluster.
        #[prost(message, tag = "16")]
        PostgresqlConfig14(super::config::PostgresqlConfig14),
        /// Configuration for a PostgreSQL 14 1C cluster.
        #[prost(message, tag = "19")]
        PostgresqlConfig141c(super::config::PostgresqlConfig141c),
        /// Configuration for a PostgreSQL 15 cluster.
        #[prost(message, tag = "21")]
        PostgresqlConfig15(super::config::PostgresqlConfig15),
        /// Configuration for a PostgreSQL 15 1C cluster.
        #[prost(message, tag = "22")]
        PostgresqlConfig151c(super::config::PostgresqlConfig151c),
        /// Configuration for a PostgreSQL 16 cluster.
        #[prost(message, tag = "24")]
        PostgresqlConfig16(super::config::PostgresqlConfig16),
        /// Configuration for a PostgreSQL 16 1C cluster.
        #[prost(message, tag = "25")]
        PostgresqlConfig161c(super::config::PostgresqlConfig161c),
        /// Configuration for a PostgreSQL 17 cluster.
        #[prost(message, tag = "27")]
        PostgresqlConfig17(super::config::PostgresqlConfig17),
        /// Configuration for a PostgreSQL 17 1C cluster.
        #[prost(message, tag = "28")]
        PostgresqlConfig171c(super::config::PostgresqlConfig171c),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConfigHostSpec {
    #[prost(
        oneof = "config_host_spec::PostgresqlConfig",
        tags = "1, 4, 2, 3, 6, 5, 7, 8, 10, 9, 11, 12, 13, 14, 15, 16, 17"
    )]
    pub postgresql_config: ::core::option::Option<config_host_spec::PostgresqlConfig>,
}
/// Nested message and enum types in `ConfigHostSpec`.
pub mod config_host_spec {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum PostgresqlConfig {
        /// Configuration for a host with PostgreSQL 9.6 server deployed.
        #[prost(message, tag = "1")]
        PostgresqlConfig96(super::config::PostgresqlHostConfig96),
        /// Configuration for a host with PostgreSQL 10 1C server deployed.
        #[prost(message, tag = "4")]
        PostgresqlConfig101c(super::config::PostgresqlHostConfig101c),
        /// Configuration for a host with PostgreSQL 10 server deployed.
        #[prost(message, tag = "2")]
        PostgresqlConfig10(super::config::PostgresqlHostConfig10),
        /// Configuration for a host with PostgreSQL 11 server deployed.
        #[prost(message, tag = "3")]
        PostgresqlConfig11(super::config::PostgresqlHostConfig11),
        /// Configuration for a host with PostgreSQL 11 1C server deployed.
        #[prost(message, tag = "6")]
        PostgresqlConfig111c(super::config::PostgresqlHostConfig111c),
        /// Configuration for a host with PostgreSQL 12 server deployed.
        #[prost(message, tag = "5")]
        PostgresqlConfig12(super::config::PostgresqlHostConfig12),
        /// Configuration for a host with PostgreSQL 12 1C server deployed.
        #[prost(message, tag = "7")]
        PostgresqlConfig121c(super::config::PostgresqlHostConfig121c),
        /// Configuration for a host with PostgreSQL 13 server deployed.
        #[prost(message, tag = "8")]
        PostgresqlConfig13(super::config::PostgresqlHostConfig13),
        /// Configuration for a host with PostgreSQL 13 1C server deployed.
        #[prost(message, tag = "10")]
        PostgresqlConfig131c(super::config::PostgresqlHostConfig131c),
        /// Configuration for a host with PostgreSQL 14 server deployed.
        #[prost(message, tag = "9")]
        PostgresqlConfig14(super::config::PostgresqlHostConfig14),
        /// Configuration for a host with PostgreSQL 14 1C server deployed.
        #[prost(message, tag = "11")]
        PostgresqlConfig141c(super::config::PostgresqlHostConfig141c),
        /// Configuration for a host with PostgreSQL 15 server deployed.
        #[prost(message, tag = "12")]
        PostgresqlConfig15(super::config::PostgresqlHostConfig15),
        /// Configuration for a host with PostgreSQL 15 1C server deployed.
        #[prost(message, tag = "13")]
        PostgresqlConfig151c(super::config::PostgresqlHostConfig151c),
        /// Configuration for a host with PostgreSQL 16 server deployed.
        #[prost(message, tag = "14")]
        PostgresqlConfig16(super::config::PostgresqlHostConfig16),
        /// Configuration for a host with PostgreSQL 16 1C server deployed.
        #[prost(message, tag = "15")]
        PostgresqlConfig161c(super::config::PostgresqlHostConfig161c),
        /// Configuration for a host with PostgreSQL 17 1C server deployed.
        #[prost(message, tag = "16")]
        PostgresqlConfig17(super::config::PostgresqlHostConfig17),
        /// Configuration for a host with PostgreSQL 17 1C server deployed.
        #[prost(message, tag = "17")]
        PostgresqlConfig171c(super::config::PostgresqlHostConfig171c),
    }
}
/// 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 PostgreSQL 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 PostgreSQL Cluster resource.
        ///
        /// To get the list of available PostgreSQL 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.postgresql.v1.ClusterService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of PostgreSQL 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.postgresql.v1.ClusterService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a PostgreSQL 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.postgresql.v1.ClusterService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified PostgreSQL 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.postgresql.v1.ClusterService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified PostgreSQL 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.postgresql.v1.ClusterService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Start the specified PostgreSQL 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.postgresql.v1.ClusterService/Start",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "Start",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Stop the specified PostgreSQL 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.postgresql.v1.ClusterService/Stop",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "Stop",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Moves the specified PostgreSQL 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.postgresql.v1.ClusterService/Move",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "Move",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a backup for the specified PostgreSQL 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.postgresql.v1.ClusterService/Backup",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "Backup",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new PostgreSQL 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.postgresql.v1.ClusterService/Restore",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.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.postgresql.v1.ClusterService/RescheduleMaintenance",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "RescheduleMaintenance",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Start a manual failover on the specified PostgreSQL cluster.
        pub async fn start_failover(
            &mut self,
            request: impl tonic::IntoRequest<super::StartClusterFailoverRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.mdb.postgresql.v1.ClusterService/StartFailover",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "StartFailover",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves logs for the specified PostgreSQL cluster.
        pub async fn list_logs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListClusterLogsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListClusterLogsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.mdb.postgresql.v1.ClusterService/ListLogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.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.postgresql.v1.ClusterService/StreamLogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.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.postgresql.v1.ClusterService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of available backups for the specified PostgreSQL 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.postgresql.v1.ClusterService/ListBackups",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.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.postgresql.v1.ClusterService/ListHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.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.postgresql.v1.ClusterService/AddHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.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.postgresql.v1.ClusterService/DeleteHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "DeleteHosts",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified hosts.
        pub async fn update_hosts(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateClusterHostsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::operation::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.mdb.postgresql.v1.ClusterService/UpdateHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ClusterService",
                        "UpdateHosts",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetDatabaseRequest {
    /// ID of the PostgreSQL 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 PostgreSQL Database resource 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 PostgreSQL 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 PostgreSQL Database resources.
    #[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 PostgreSQL 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 PostgreSQL cluster where a database is being created.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the PostgreSQL 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 UpdateDatabaseRequest {
    /// ID of the PostgreSQL cluster to update 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 update.
    /// To get the name of the database use a \[DatabaseService.List\] request.
    #[prost(string, tag = "2")]
    pub database_name: ::prost::alloc::string::String,
    /// Optional. New name of the database.
    #[prost(string, tag = "5")]
    pub new_database_name: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the Database resource should be updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// PostgreSQL extensions that should be enabled for the database.
    ///
    /// If the field is sent, the list of enabled extensions is rewritten entirely.
    /// Therefore, to disable an active extension you should simply send the list omitting this extension.
    #[prost(message, repeated, tag = "4")]
    pub extensions: ::prost::alloc::vec::Vec<Extension>,
    /// Deletion Protection inhibits deletion of the database
    ///
    /// Default value: `unspecified` (inherits cluster's deletion_protection)
    #[prost(message, optional, tag = "6")]
    pub deletion_protection: ::core::option::Option<bool>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateDatabaseMetadata {
    /// ID of the PostgreSQL cluster where a database is being updated.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the PostgreSQL database that is being updated.
    #[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 PostgreSQL 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 PostgreSQL cluster where a database is being deleted.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the PostgreSQL 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 PostgreSQL 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 PostgreSQL Database resource.
        ///
        /// To get the list of available PostgreSQL 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.postgresql.v1.DatabaseService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.DatabaseService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of PostgreSQL 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.postgresql.v1.DatabaseService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.DatabaseService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new PostgreSQL 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.postgresql.v1.DatabaseService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.DatabaseService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified PostgreSQL database.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateDatabaseRequest>,
        ) -> 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.postgresql.v1.DatabaseService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.DatabaseService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified PostgreSQL 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.postgresql.v1.DatabaseService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.DatabaseService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SessionState {
    /// Time of collecting statistics on sessions (in the \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format).
    #[prost(message, optional, tag = "1")]
    pub time: ::core::option::Option<::prost_types::Timestamp>,
    /// Host of the connected client.
    #[prost(string, tag = "2")]
    pub host: ::prost::alloc::string::String,
    /// Server process ID. For client connections, this is a client connection ID.
    #[prost(int64, tag = "3")]
    pub pid: i64,
    /// Database ID.
    #[prost(string, tag = "4")]
    pub database: ::prost::alloc::string::String,
    /// User ID.
    #[prost(string, tag = "5")]
    pub user: ::prost::alloc::string::String,
    /// Application name on the connected client.
    #[prost(string, tag = "6")]
    pub application_name: ::prost::alloc::string::String,
    /// Time when a given process was started. For client connections, this is the time when the client connected to the server.
    #[prost(message, optional, tag = "7")]
    pub backend_start: ::core::option::Option<::prost_types::Timestamp>,
    /// Time when a transaction of a given process was started. Returns \[NULL\] if no transaction is active.
    ///
    /// If the currently active query is the first of its transaction, the value of this parameter is equal to the value of the \[query_start\] parameter.
    #[prost(message, optional, tag = "8")]
    pub xact_start: ::core::option::Option<::prost_types::Timestamp>,
    /// Time when the currently active query was started.
    ///
    /// If the \[state\] parameter does not take the value \[active\], the parameter returns the time when the lastest query was started.
    #[prost(message, optional, tag = "9")]
    pub query_start: ::core::option::Option<::prost_types::Timestamp>,
    /// Time when the \[state\] parameter was last changed.
    #[prost(message, optional, tag = "10")]
    pub state_change: ::core::option::Option<::prost_types::Timestamp>,
    /// Type of event for which the backend is waiting. Such an event is called a wait event. A backend refers to the process that maintains the client connection.
    ///
    /// For the list of wait events, see the [PostgreSQL documentation](<https://www.postgresql.org/docs/current/monitoring-stats.html#WAIT-EVENT-TABLE>). If the backend is not waiting for any event, the parameter returns \[NULL\].
    #[prost(string, tag = "11")]
    pub wait_event_type: ::prost::alloc::string::String,
    /// Wait event name.
    ///
    /// For the list of such names, see the [PostgreSQL documentation](<https://www.postgresql.org/docs/current/monitoring-stats.html#WAIT-EVENT-ACTIVITY-TABLE>). If the backend is not waiting for any event, the parameter returns \[NULL\].
    #[prost(string, tag = "12")]
    pub wait_event: ::prost::alloc::string::String,
    /// Current backend state. For the list of possible values, see the [PostgreSQL documentation](<https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ACTIVITY-VIEW>).
    #[prost(string, tag = "13")]
    pub state: ::prost::alloc::string::String,
    /// Text of the most recent query.
    ///
    /// If the \[state\] parameter takes the value \[active\], the parameter shows the currently executing query. For the rest of the states, the parameter shows the last query that was executed. By default, the query text is truncated to 1024 bytes.
    #[prost(string, tag = "14")]
    pub query: ::prost::alloc::string::String,
    /// Current backend type. For the list of possible values, see the [PostgreSQL documentation](<https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ACTIVITY-VIEW>).
    #[prost(string, tag = "15")]
    pub backend_type: ::prost::alloc::string::String,
    /// IP address of the connected client.
    ///
    /// The parameter returns \[NULL\] in the following cases:
    /// - The client is connected via a Unix socket on the server.
    /// - A given process is internal (for example, autovacuum).
    #[prost(string, tag = "16")]
    pub client_addr: ::prost::alloc::string::String,
    /// Host name of the connected client (relevant for IP connections).
    #[prost(string, tag = "17")]
    pub client_hostname: ::prost::alloc::string::String,
    /// TCP port number that the client is using for communication with the server.
    ///
    /// Returns \[-1\] if the client is connected via a Unix socket on the server. Returns \[NULL\] if a given process is internal (for example, autovacuum).
    #[prost(int64, tag = "18")]
    pub client_port: i64,
    /// Top-level transaction ID, if any.
    #[prost(int64, tag = "19")]
    pub backend_xid: i64,
    /// Current [xmin horizon].
    #[prost(int64, tag = "20")]
    pub backend_xmin: i64,
    /// Process IDs that are blocking a given server process ID.
    #[prost(string, tag = "22")]
    pub blocking_pids: ::prost::alloc::string::String,
    /// Query ID.
    #[prost(string, tag = "23")]
    pub query_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PrimaryKey {
    /// Host of the connected client.
    #[prost(string, tag = "1")]
    pub host: ::prost::alloc::string::String,
    /// User ID.
    #[prost(string, tag = "2")]
    pub user: ::prost::alloc::string::String,
    /// Database ID.
    #[prost(string, tag = "4")]
    pub database: ::prost::alloc::string::String,
    /// Returns \[true\] if a query is executed as a top-level SQL statement or if the \[pg_stat_statements.track\](<https://www.postgresql.org/docs/current/pgstatstatements.html#id-1.11.7.41.9>) parameter is set to the value \[top\].
    #[prost(bool, tag = "5")]
    pub toplevel: bool,
    /// Query ID.
    #[prost(string, tag = "6")]
    pub query_id: ::prost::alloc::string::String,
    /// Query planning ID.
    #[prost(string, tag = "7")]
    pub plan_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryStats {
    /// Time of collecting statistics on planning and execution of queries.
    #[prost(message, optional, tag = "1")]
    pub time: ::core::option::Option<::prost_types::Timestamp>,
    /// Statement text.
    #[prost(string, tag = "2")]
    pub query: ::prost::alloc::string::String,
    /// Normalized query plan.
    #[prost(string, tag = "3")]
    pub normalized_plan: ::prost::alloc::string::String,
    /// Example of a query execution plan (without normalization).
    #[prost(string, tag = "4")]
    pub example_plan: ::prost::alloc::string::String,
    /// Number of times that a query was planned.
    ///
    /// The parameter returns a non-zero value if the \[pg_stat_statements.track_planning\](<https://www.postgresql.org/docs/current/pgstatstatements.html#id-1.11.7.41.9>) parameter is enabled.
    #[prost(int64, tag = "5")]
    pub plans: i64,
    /// Total time taken to plan a query, in milliseconds.
    ///
    /// The parameter returns a non-zero value if the \[pg_stat_statements.track_planning\] parameter is enabled.
    #[prost(double, tag = "6")]
    pub total_plan_time: f64,
    /// Minimum time taken to plan a query, in milliseconds.
    ///
    /// The parameter returns a non-zero value if the \[pg_stat_statements.track_planning\] parameter is enabled.
    #[prost(double, tag = "7")]
    pub min_plan_time: f64,
    /// Maximum time taken to plan a query, in milliseconds.
    ///
    /// The parameter returns a non-zero value if the \[pg_stat_statements.track_planning\] parameter is enabled.
    #[prost(double, tag = "8")]
    pub max_plan_time: f64,
    /// Average time taken to plan a query, in milliseconds.
    ///
    /// The parameter returns a non-zero value if the \[pg_stat_statements.track_planning\] parameter is enabled.
    #[prost(double, tag = "9")]
    pub mean_plan_time: f64,
    /// Population standard deviation of the time taken to plan a query, in milliseconds.
    ///
    /// The parameter returns a non-zero value if the \[pg_stat_statements.track_planning\] parameter is enabled.
    #[prost(double, tag = "10")]
    pub stddev_plan_time: f64,
    /// Number of times that a query was executed.
    #[prost(int64, tag = "11")]
    pub calls: i64,
    /// Total time taken to execute a query, in milliseconds.
    ///
    /// total_exec_time
    #[prost(double, tag = "12")]
    pub total_time: f64,
    /// Minimum time taken to execute a query, in milliseconds.
    ///
    /// min_exec_time
    #[prost(double, tag = "13")]
    pub min_time: f64,
    /// Maximum time taken to execute a query, in milliseconds.
    ///
    /// max_exec_time
    #[prost(double, tag = "14")]
    pub max_time: f64,
    /// Average time taken to execute a query, in milliseconds.
    ///
    /// mean_exec_time
    #[prost(double, tag = "15")]
    pub mean_time: f64,
    /// Population standard deviation of the time taken to execute a query, in milliseconds.
    ///
    /// stddev_exec_time
    #[prost(double, tag = "16")]
    pub stddev_time: f64,
    /// Number of retrieved or affected rows.
    #[prost(int64, tag = "17")]
    pub rows: i64,
    /// Number of shared blocks that are hit from cache.
    #[prost(int64, tag = "18")]
    pub shared_blks_hit: i64,
    /// Number of read shared blocks.
    #[prost(int64, tag = "19")]
    pub shared_blks_read: i64,
    /// Number of 'dirtied' shared blocks.
    #[prost(int64, tag = "20")]
    pub shared_blks_dirtied: i64,
    /// Number of written shared blocks.
    #[prost(int64, tag = "21")]
    pub shared_blks_written: i64,
    /// Number of local blocks that are hit from cache.
    #[prost(int64, tag = "22")]
    pub local_blks_hit: i64,
    /// Number of read local blocks.
    #[prost(int64, tag = "23")]
    pub local_blks_read: i64,
    /// Number of 'dirtied' local blocks.
    #[prost(int64, tag = "24")]
    pub local_blks_dirtied: i64,
    /// Number of written local blocks.
    #[prost(int64, tag = "25")]
    pub local_blks_written: i64,
    /// Number of read temporary blocks.
    #[prost(int64, tag = "26")]
    pub temp_blks_read: i64,
    /// Number of written temporary blocks.
    #[prost(int64, tag = "27")]
    pub temp_blks_written: i64,
    /// Time taken to read data blocks, in milliseconds.
    ///
    /// The parameter returns a non-zero value if the \[track_io_timing\](<https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-IO-TIMING>) parameter is enabled.
    #[prost(double, tag = "28")]
    pub blk_read_time: f64,
    /// Time taken to record data blocks, in milliseconds.
    ///
    /// The parameter returns a non-zero value if the \[track_io_timing\] parameter is enabled.
    #[prost(double, tag = "29")]
    pub blk_write_time: f64,
    /// Time taken to read temporary data blocks, in milliseconds.
    ///
    /// The parameter returns a non-zero value if the \[track_io_timing\] parameter is enabled.
    #[prost(double, tag = "30")]
    pub temp_blk_read_time: f64,
    /// Time taken to record temporary data blocks, in milliseconds.
    ///
    /// The parameter returns a non-zero value if the \[track_io_timing\] parameter is enabled.
    #[prost(double, tag = "31")]
    pub temp_blk_write_time: f64,
    /// Number of WAL records generated during a given period.
    #[prost(int64, tag = "32")]
    pub wal_records: i64,
    /// Number of WAL full page images generated during a given period.
    #[prost(int64, tag = "33")]
    pub wal_fpi: i64,
    /// Number of WAL logs generated during a given period, in bytes.
    #[prost(int64, tag = "34")]
    pub wal_bytes: i64,
    /// Number of JIT-compiled functions.
    #[prost(int64, tag = "35")]
    pub jit_functions: i64,
    /// Time taken to generate JIT code, in milliseconds.
    #[prost(double, tag = "36")]
    pub jit_generation_time: f64,
    /// Number of times that functions have been inlined.
    #[prost(int64, tag = "37")]
    pub jit_inlining_count: i64,
    /// Time taken to inline functions, in milliseconds.
    #[prost(double, tag = "38")]
    pub jit_inlining_time: f64,
    /// Number of times that a query was optimized.
    #[prost(int64, tag = "39")]
    pub jit_optimization_count: i64,
    /// Time taken to optimize a query, in milliseconds.
    #[prost(double, tag = "40")]
    pub jit_optimization_time: f64,
    /// Number of times that code was emitted.
    #[prost(int64, tag = "41")]
    pub jit_emission_count: i64,
    /// Time taken to emit code.
    #[prost(double, tag = "42")]
    pub jit_emission_time: f64,
    /// Cost of receiving a response to a query before the first row of the response is issued.
    #[prost(int64, tag = "43")]
    pub startup_cost: i64,
    /// Cost of receiving a response to a query when all the rows of the response are issued.
    #[prost(int64, tag = "44")]
    pub total_cost: i64,
    /// Expected number of rows that a given plan node should issue.
    #[prost(int64, tag = "45")]
    pub plan_rows: i64,
    /// Expected average size of rows that a given plan node should issue.
    #[prost(int64, tag = "46")]
    pub plan_width: i64,
    /// Number of bytes that the filesystem layer has read.
    #[prost(int64, tag = "47")]
    pub reads: i64,
    /// Number of bytes that the filesystem layer has written.
    #[prost(int64, tag = "48")]
    pub writes: i64,
    /// User CPU time used.
    #[prost(double, tag = "49")]
    pub user_time: f64,
    /// System CPU time used.
    #[prost(double, tag = "50")]
    pub system_time: f64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryStatement {
    /// Primary keys in tables with the statistics on planning and execution of queries.
    #[prost(message, optional, tag = "1")]
    pub key: ::core::option::Option<PrimaryKey>,
    /// Statistics on planning and execution of queries.
    #[prost(message, optional, tag = "2")]
    pub stats: ::core::option::Option<QueryStats>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRawStatementsRequest {
    /// ID of a PostgreSQL cluster to request query statistics for.
    ///
    /// To get a PostgreSQL cluster ID, use the \[ClusterService.List\] method.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Beginning of the period for which you need to request data (in the \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format).
    #[prost(message, optional, tag = "2")]
    pub from_time: ::core::option::Option<::prost_types::Timestamp>,
    /// End of the period for which you need to request data (in the \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format).
    #[prost(message, optional, tag = "3")]
    pub to_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The maximum number of results per page to return. If the number of the results is larger than \[page_size\], the service returns \[ListRawStatementsResponse.next_page_token\]. You can use it to get the next page of the results in subsequent requests.
    #[prost(int64, tag = "4")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the \[ListRawStatementsResponse.next_page_token\] returned by the previous SQL statement list request.
    #[prost(string, tag = "5")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRawSessionStatesRequest {
    /// ID of a PostgreSQL cluster to request session statistics for.
    ///
    /// To get a PostgreSQL cluster ID, use the \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Beginning of the period for which you need to request data (in the \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format).
    #[prost(message, optional, tag = "2")]
    pub from_time: ::core::option::Option<::prost_types::Timestamp>,
    /// End of the period for which you need to request data (in the \[RFC3339\](<https://www.ietf.org/rfc/rfc3339.txt>) text format).
    #[prost(message, optional, tag = "3")]
    pub to_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The maximum number of results per page to return. If the number of the results is larger than \[page_size\], the service returns \[ListRawSessionStatesResponse.next_page_token\]. You can use it to get the next page of the results in subsequent requests.
    #[prost(int64, tag = "4")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the \[ListRawSessionStatesResponse.next_page_token\] returned by the previous PostgreSQL session list request.
    #[prost(string, tag = "5")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRawSessionStatesResponse {
    /// List of PostgreSQL sessions.
    #[prost(message, repeated, tag = "1")]
    pub session_states: ::prost::alloc::vec::Vec<SessionState>,
    /// This token allows you to get the next page of results when requesting the PostgreSQL session list. If the number of the results is larger than \[ListRawSessionStatesRequest.page_size\], use the \[next_page_token\] as the value for the \[ListRawSessionStatesRequest.page_token\] parameter in the next request. Each subsequent 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 ListRawStatementsResponse {
    /// List of SQL statements (queries).
    #[prost(message, repeated, tag = "1")]
    pub statements: ::prost::alloc::vec::Vec<QueryStatement>,
    /// This token allows you to get the next page of results when requesting the PostgreSQL session list. If the number of the results is larger than \[ListRawStatementsRequest.page_size\], use the \[next_page_token\] as the value for the \[ListRawStatementsRequest.page_token\] parameter in the next request. Each subsequent 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 performance_diagnostics_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 PostgreSQL performance diagnostics.
    #[derive(Debug, Clone)]
    pub struct PerformanceDiagnosticsServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl PerformanceDiagnosticsServiceClient<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> PerformanceDiagnosticsServiceClient<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,
        ) -> PerformanceDiagnosticsServiceClient<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,
        {
            PerformanceDiagnosticsServiceClient::new(
                InterceptedService::new(inner, interceptor),
            )
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Retrieves raw statistics on sessions. Corresponds to the [pg_stat_activity view](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ACTIVITY-VIEW).
        pub async fn list_raw_session_states(
            &mut self,
            request: impl tonic::IntoRequest<super::ListRawSessionStatesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListRawSessionStatesResponse>,
            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.postgresql.v1.PerformanceDiagnosticsService/ListRawSessionStates",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.PerformanceDiagnosticsService",
                        "ListRawSessionStates",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves statistics on planning and execution of SQL statements (queries).
        pub async fn list_raw_statements(
            &mut self,
            request: impl tonic::IntoRequest<super::ListRawStatementsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListRawStatementsResponse>,
            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.postgresql.v1.PerformanceDiagnosticsService/ListRawStatements",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.PerformanceDiagnosticsService",
                        "ListRawStatements",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A ResourcePreset resource for describing hardware configuration presets.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResourcePreset {
    /// ID of the ResourcePreset resource.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// IDs of availability zones where the resource preset is available.
    #[prost(string, repeated, tag = "2")]
    pub zone_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Number of CPU cores for a PostgreSQL host created with the preset.
    #[prost(int64, tag = "3")]
    pub cores: i64,
    /// RAM volume for a PostgreSQL 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.
    #[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.postgresql.v1.ResourcePresetService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.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.postgresql.v1.ResourcePresetService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.ResourcePresetService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetUserRequest {
    /// ID of the PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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,
    /// Set of permissions granted to the user to access specific databases.
    #[prost(message, repeated, tag = "5")]
    pub permissions: ::prost::alloc::vec::Vec<Permission>,
    /// Maximum number of database connections available to the user.
    ///
    /// When used in session pooling, this setting limits the number of connections to every single host in PostgreSQL cluster. In this case, the setting's value must be greater than the total number of connections that backend services can open to access the PostgreSQL cluster. The setting's value should not exceed the value of the \[Cluster.config.postgresql_config.max_connections\] setting.
    ///
    /// When used in transaction pooling, this setting limits the number of user's active transactions; therefore, in this mode user can open thousands of connections, but only `N` concurrent connections will be opened, where `N` is the value of the setting.
    ///
    /// Minimum value: `10` (default: `50`), when used in session pooling.
    #[prost(int64, tag = "6")]
    pub conn_limit: i64,
    #[prost(message, optional, tag = "7")]
    pub settings: ::core::option::Option<UserSettings>,
    /// This flag defines whether the user can login to a PostgreSQL database.
    ///
    /// Default value: `true` (login is allowed).
    #[prost(message, optional, tag = "8")]
    pub login: ::core::option::Option<bool>,
    /// A set of roles and privileges that are granted to the user.
    ///
    /// For more information, see [the documentation](/docs/managed-postgresql/operations/grant).
    #[prost(string, repeated, tag = "9")]
    pub grants: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Deletion Protection inhibits deletion of the user
    ///
    /// Default value: `unspecified` (inherits cluster's deletion_protection)
    #[prost(message, optional, tag = "10")]
    pub deletion_protection: ::core::option::Option<bool>,
    /// New password-based authentication method for user.
    /// Possible values are `` USER_PASSWORD_ENCRYPTION_MD5 `` or `` USER_PASSWORD_ENCRYPTION_SCRAM_SHA_256 ``.
    #[prost(enumeration = "UserPasswordEncryption", tag = "11")]
    pub user_password_encryption: i32,
    /// Generate password using Connection Manager.
    #[prost(message, optional, tag = "12")]
    pub generate_password: ::core::option::Option<bool>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateUserMetadata {
    /// ID of the PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL User resource.
        ///
        /// To get the list of available PostgreSQL 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.postgresql.v1.UserService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.postgresql.v1.UserService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of PostgreSQL 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.postgresql.v1.UserService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.postgresql.v1.UserService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a PostgreSQL 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.postgresql.v1.UserService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.UserService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified PostgreSQL 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.postgresql.v1.UserService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.UserService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified PostgreSQL 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.postgresql.v1.UserService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.UserService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Grants permission to the specified PostgreSQL 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.postgresql.v1.UserService/GrantPermission",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.UserService",
                        "GrantPermission",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Revokes permission from the specified PostgreSQL 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.postgresql.v1.UserService/RevokePermission",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.postgresql.v1.UserService",
                        "RevokePermission",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}