yandex_cloud/

yandex.cloud.mdb.sqlserver.v1.rs

/// An SQL Server backup resource.
///
/// For more information, see the \[Backup\](/docs/managed-sqlserver/concepts/backup) section in the documentation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Backup {
    /// ID of the backup.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the backup belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Time when the backup operation was completed.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// ID of the SQL Server 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>,
    /// List of databases included in the backup.
    #[prost(string, repeated, tag = "6")]
    pub databases: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[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 SQL Server backups.
    #[prost(message, repeated, tag = "1")]
    pub backups: ::prost::alloc::vec::Vec<Backup>,
    /// This token allows you to get the next page of results for ListBackups 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 ListBackups request.
    ///
    /// Each subsequent ListBackups request has 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 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 SQL Server backups.
    #[derive(Debug, Clone)]
    pub struct BackupServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl BackupServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> BackupServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> BackupServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            BackupServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the specified SQL Server backup.
        ///
        /// To get the list of available SQL Server backups, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetBackupRequest>,
        ) -> std::result::Result<tonic::Response<super::Backup>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.mdb.sqlserver.v1.BackupService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.sqlserver.v1.BackupService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of SQL Server backups available for the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListBackupsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListBackupsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.mdb.sqlserver.v1.BackupService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.BackupService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// An SQL Server cluster.
///
/// For more information, see the \[Concepts\](/docs/managed-sqlserver/concepts) section of the documentation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Cluster {
    /// ID of the SQL Server cluster.
    ///
    /// This ID is assigned by Managed Service for SQL Server at the moment of creation.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder the SQL Server cluster belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Time when SQL Server cluster was created.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the SQL Server cluster.
    ///
    /// The name must be unique within the folder, comply with [RFC 1035](<https://www.ietf.org/rfc/rfc1035.txt>) and be 1-63 characters long.
    ///
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the SQL Server cluster.
    ///
    /// Must be 0-256 characters long.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the SQL Server 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 SQL Server cluster.
    #[prost(enumeration = "cluster::Environment", tag = "7")]
    pub environment: i32,
    /// Description of monitoring systems relevant to the SQL Server cluster.
    #[prost(message, repeated, tag = "8")]
    pub monitoring: ::prost::alloc::vec::Vec<Monitoring>,
    /// Configuration of the SQL Server 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,
    /// User security groups.
    #[prost(string, repeated, tag = "13")]
    pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Determines whether the cluster is protected from being deleted.
    #[prost(bool, tag = "14")]
    pub deletion_protection: bool,
    /// SQL Server Collation.
    #[prost(string, tag = "15")]
    pub sqlcollation: ::prost::alloc::string::String,
    /// Host groups hosting VMs of the cluster.
    #[prost(string, repeated, tag = "16")]
    pub host_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// ID of the service account which is used for access to Object Storage.
    #[prost(string, tag = "17")]
    pub service_account_id: ::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\] of all hosts in the cluster is `UNKNOWN`).
        Unknown = 0,
        /// Cluster is alive and works well (\[Host.health\] of all hosts in the cluster is `ALIVE`).
        Alive = 1,
        /// Cluster is inoperable (\[Host.health\] of all hosts in the cluster is `DEAD`).
        Dead = 2,
        /// Cluster is in degraded state (\[Host.health\] of at least one of the hosts 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,
            }
        }
    }
}
#[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 SQL Server 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 the SQL Server.
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    /// Resources allocated to SQL Server hosts.
    #[prost(message, optional, tag = "3")]
    pub resources: ::core::option::Option<Resources>,
    /// Start time for the daily backup in UTC timezone.
    ///
    #[prost(message, optional, tag = "4")]
    pub backup_window_start: ::core::option::Option<
        super::super::super::super::super::google::r#type::TimeOfDay,
    >,
    /// Database access policy.
    #[prost(message, optional, tag = "6")]
    pub access: ::core::option::Option<Access>,
    /// Secondary replicas connection mode
    #[prost(enumeration = "cluster_config::SecondaryConnections", tag = "7")]
    pub secondary_connections: i32,
    /// Configuration of the SQL Server instances in the cluster.
    #[prost(oneof = "cluster_config::SqlserverConfig", tags = "2, 5, 8, 9, 10, 11")]
    pub sqlserver_config: ::core::option::Option<cluster_config::SqlserverConfig>,
}
/// Nested message and enum types in `ClusterConfig`.
pub mod cluster_config {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum SecondaryConnections {
        Unspecified = 0,
        /// Connections to secondary replicas are prohibited
        Off = 1,
        /// Secondary replicas are read-only
        ReadOnly = 2,
    }
    impl SecondaryConnections {
        /// 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 {
                SecondaryConnections::Unspecified => "SECONDARY_CONNECTIONS_UNSPECIFIED",
                SecondaryConnections::Off => "SECONDARY_CONNECTIONS_OFF",
                SecondaryConnections::ReadOnly => "SECONDARY_CONNECTIONS_READ_ONLY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SECONDARY_CONNECTIONS_UNSPECIFIED" => Some(Self::Unspecified),
                "SECONDARY_CONNECTIONS_OFF" => Some(Self::Off),
                "SECONDARY_CONNECTIONS_READ_ONLY" => Some(Self::ReadOnly),
                _ => None,
            }
        }
    }
    /// Configuration of the SQL Server instances in the cluster.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum SqlserverConfig {
        /// Configuration of the SQL Server 2016sp2 standard edition instance.
        #[prost(message, tag = "2")]
        SqlserverConfig2016sp2std(super::config::SqlServerConfigSet2016sp2std),
        /// Configuration of the SQL Server 2016sp2 enterprise edition instance.
        #[prost(message, tag = "5")]
        SqlserverConfig2016sp2ent(super::config::SqlServerConfigSet2016sp2ent),
        /// Configuration of the SQL Server 2017 standard edition instance.
        #[prost(message, tag = "8")]
        SqlserverConfig2017std(super::config::SqlServerConfigSet2017std),
        /// Configuration of the SQL Server 2017 enterprise edition instance.
        #[prost(message, tag = "9")]
        SqlserverConfig2017ent(super::config::SqlServerConfigSet2017ent),
        /// Configuration of the SQL Server 2019 standard edition instance.
        #[prost(message, tag = "10")]
        SqlserverConfig2019std(super::config::SqlServerConfigSet2019std),
        /// Configuration of the SQL Server 2019 enterprise edition instance.
        #[prost(message, tag = "11")]
        SqlserverConfig2019ent(super::config::SqlServerConfigSet2019ent),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Host {
    /// Name of the SQL Server host.
    ///
    /// The host name is assigned by Managed Service for SQL Server at the moment of creation and cannot be changed. 1-63 characters long.
    ///
    /// The name is unique across all database 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 SQL Server host.
    ///
    /// The ID is assigned by Managed Service for SQL Server at the moment of creation.
    #[prost(string, tag = "2")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the availability zone where the SQL Server host resides.
    #[prost(string, tag = "3")]
    pub zone_id: ::prost::alloc::string::String,
    /// Resources allocated to the host.
    #[prost(message, optional, tag = "4")]
    pub resources: ::core::option::Option<Resources>,
    /// Role of the host in the cluster.
    #[prost(enumeration = "host::Role", tag = "5")]
    pub role: i32,
    /// Status code of the aggregated health of the host.
    #[prost(enumeration = "host::Health", tag = "6")]
    pub health: i32,
    /// Services provided by the host.
    #[prost(message, repeated, tag = "7")]
    pub services: ::prost::alloc::vec::Vec<Service>,
    /// ID of the subnet that the host belongs to.
    #[prost(string, tag = "8")]
    pub subnet_id: ::prost::alloc::string::String,
    /// Flag showing public IP assignment status to this host.
    #[prost(bool, tag = "9")]
    pub assign_public_ip: bool,
}
/// 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.
        Unknown = 0,
        /// Host is the master SQL Server instance in the cluster.
        Master = 1,
        /// Host is a replica SQL Server instance in the cluster.
        Replica = 2,
    }
    impl Role {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Role::Unknown => "ROLE_UNKNOWN",
                Role::Master => "MASTER",
                Role::Replica => "REPLICA",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ROLE_UNKNOWN" => Some(Self::Unknown),
                "MASTER" => Some(Self::Master),
                "REPLICA" => Some(Self::Replica),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Health {
        /// Health of the host is unknown.
        Unknown = 0,
        /// The host is performing all its functions normally.
        Alive = 1,
        /// The host is inoperable and cannot perform any of its essential functions.
        Dead = 2,
        /// The host is degraded and can perform only some of its essential functions.
        Degraded = 3,
    }
    impl Health {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Health::Unknown => "HEALTH_UNKNOWN",
                Health::Alive => "ALIVE",
                Health::Dead => "DEAD",
                Health::Degraded => "DEGRADED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "HEALTH_UNKNOWN" => Some(Self::Unknown),
                "ALIVE" => Some(Self::Alive),
                "DEAD" => Some(Self::Dead),
                "DEGRADED" => Some(Self::Degraded),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Service {
    /// Type of the service provided by the host.
    #[prost(enumeration = "service::Type", tag = "1")]
    pub r#type: i32,
    /// Status code of server availability.
    #[prost(enumeration = "service::Health", tag = "2")]
    pub health: i32,
}
/// Nested message and enum types in `Service`.
pub mod service {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        Unspecified = 0,
        /// SQL Server service.
        Sqlserver = 1,
    }
    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::Sqlserver => "SQLSERVER",
            }
        }
        /// 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),
                "SQLSERVER" => Some(Self::Sqlserver),
                _ => None,
            }
        }
    }
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Health {
        /// Health of the server is unknown.
        Unknown = 0,
        /// The server is working normally.
        Alive = 1,
        /// The server is dead or unresponsive.
        Dead = 2,
    }
    impl Health {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Health::Unknown => "HEALTH_UNKNOWN",
                Health::Alive => "ALIVE",
                Health::Dead => "DEAD",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "HEALTH_UNKNOWN" => Some(Self::Unknown),
                "ALIVE" => Some(Self::Alive),
                "DEAD" => Some(Self::Dead),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Resources {
    /// ID of the preset for computational resources available to a host (CPU, memory, etc.).
    ///
    /// All available presets are listed in the \[documentation\](/docs/managed-sqlserver/concepts/instance-types).
    #[prost(string, tag = "1")]
    pub resource_preset_id: ::prost::alloc::string::String,
    /// Volume of the storage available to a host.
    #[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 {
    /// Allows access for DataLens.
    #[prost(bool, tag = "1")]
    pub data_lens: bool,
    /// Allows access for Web SQL.
    #[prost(bool, tag = "2")]
    pub web_sql: bool,
}
/// An SQL Server database.
///
/// For more information, see the \[Concepts\](/docs/managed-sqlserver/concepts) section of the documentation.
#[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 SQL Server cluster that the database belongs to.
    #[prost(string, tag = "2")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DatabaseSpec {
    /// Name of the database.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// An SQL Server user.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct User {
    /// Name of the SQL Server user.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// ID of the SQL Server cluster the user belongs to.
    #[prost(string, tag = "2")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Set of permissions granted to the user.
    #[prost(message, repeated, tag = "3")]
    pub permissions: ::prost::alloc::vec::Vec<Permission>,
    /// Set of server roles granted to the login.
    #[prost(enumeration = "ServerRole", repeated, tag = "4")]
    pub server_roles: ::prost::alloc::vec::Vec<i32>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Permission {
    /// Name of the database the permission grants access to.
    #[prost(string, tag = "1")]
    pub database_name: ::prost::alloc::string::String,
    /// Roles granted to the user within the database.
    #[prost(enumeration = "permission::Role", repeated, packed = "false", tag = "2")]
    pub roles: ::prost::alloc::vec::Vec<i32>,
}
/// Nested message and enum types in `Permission`.
pub mod permission {
    /// Role granted to the user within the database.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Role {
        Unspecified = 0,
        /// Members of this fixed database role can perform all configuration and maintenance activities on a database and can also drop a database in SQL Server.
        DbOwner = 1,
        /// Members of this fixed database role can modify role membership for custom roles only and manage permissions. They can potentially elevate their privileges and their actions should be monitored.
        DbSecurityadmin = 2,
        /// Members of this fixed database role can add or remove access to a database for Windows logins, Windows groups, and SQL Server logins.
        DbAccessadmin = 3,
        /// Members of this fixed database role can back up the database.
        DbBackupoperator = 4,
        /// Members of this fixed database role can run any Data Definition Language (DDL) command in a database.
        DbDdladmin = 5,
        /// Members of this fixed database role can add, delete, or change data in all user tables.
        DbDatawriter = 6,
        /// Members of this fixed database role can read all data from all user tables.
        DbDatareader = 7,
        /// Members of this fixed database role cannot add, modify, or delete any data in the user tables within a database. A denial has a higher priority than a grant, so you can use this role to quickly restrict one's privileges without explicitly revoking permissions or roles.
        DbDenydatawriter = 8,
        /// Members of this fixed database role cannot read any data in the user tables within a database. A denial has a higher priority than a grant, so you can use this role to quickly restrict one's privileges without explicitly revoking permissions or roles.
        DbDenydatareader = 9,
    }
    impl Role {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Role::Unspecified => "ROLE_UNSPECIFIED",
                Role::DbOwner => "DB_OWNER",
                Role::DbSecurityadmin => "DB_SECURITYADMIN",
                Role::DbAccessadmin => "DB_ACCESSADMIN",
                Role::DbBackupoperator => "DB_BACKUPOPERATOR",
                Role::DbDdladmin => "DB_DDLADMIN",
                Role::DbDatawriter => "DB_DATAWRITER",
                Role::DbDatareader => "DB_DATAREADER",
                Role::DbDenydatawriter => "DB_DENYDATAWRITER",
                Role::DbDenydatareader => "DB_DENYDATAREADER",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ROLE_UNSPECIFIED" => Some(Self::Unspecified),
                "DB_OWNER" => Some(Self::DbOwner),
                "DB_SECURITYADMIN" => Some(Self::DbSecurityadmin),
                "DB_ACCESSADMIN" => Some(Self::DbAccessadmin),
                "DB_BACKUPOPERATOR" => Some(Self::DbBackupoperator),
                "DB_DDLADMIN" => Some(Self::DbDdladmin),
                "DB_DATAWRITER" => Some(Self::DbDatawriter),
                "DB_DATAREADER" => Some(Self::DbDatareader),
                "DB_DENYDATAWRITER" => Some(Self::DbDenydatawriter),
                "DB_DENYDATAREADER" => Some(Self::DbDenydatareader),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UserSpec {
    /// Name of the SQL Server user.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Password of the SQL Server user.
    #[prost(string, tag = "2")]
    pub password: ::prost::alloc::string::String,
    /// Set of permissions to grant to the user.
    #[prost(message, repeated, tag = "3")]
    pub permissions: ::prost::alloc::vec::Vec<Permission>,
    /// Set of server roles.
    #[prost(enumeration = "ServerRole", repeated, tag = "4")]
    pub server_roles: ::prost::alloc::vec::Vec<i32>,
}
/// Set of server roles.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ServerRole {
    Unspecified = 0,
    /// Effectively grants VIEW SERVER STATE to the login.
    ///
    /// That gives an ability to use various dynamic management views to monitor server state, including Activity Monitor tool that is built-in into SSMS.
    ///
    /// No intrusive actions are allowed, so this is pretty safe to grant.
    MdbMonitor = 1,
}
impl ServerRole {
    /// 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 {
            ServerRole::Unspecified => "SERVER_ROLE_UNSPECIFIED",
            ServerRole::MdbMonitor => "MDB_MONITOR",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SERVER_ROLE_UNSPECIFIED" => Some(Self::Unspecified),
            "MDB_MONITOR" => Some(Self::MdbMonitor),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetClusterRequest {
    /// ID of the SQL Server cluster to return.
    ///
    /// To get the cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClustersRequest {
    /// ID of the folder to list SQL Server 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. A field name to filter by. Currently you can only use filtering with the \[Cluster.name\] field.
    /// 2. A conditional operator. Can be either `=` or `!=` for single values, `IN` or `NOT IN` for lists of values.
    /// 3. A value. Must be 1-63 characters long and match the regular expression `\[a-zA-Z0-9_-\]+`.
    ///
    /// Example of a filter expression: `name NOT IN 'test,beta'`.
    ///
    #[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 SQL Server clusters.
    #[prost(message, repeated, tag = "1")]
    pub clusters: ::prost::alloc::vec::Vec<Cluster>,
    /// Token that 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 has its own `next_page_token` to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateClusterRequest {
    /// ID of the folder to create the SQL Server cluster 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,
    /// Name of the SQL Server cluster. The name must be unique within the folder.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the SQL Server cluster.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the SQL Server cluster as `key:value` pairs.
    /// 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 SQL Server cluster.
    #[prost(enumeration = "cluster::Environment", tag = "5")]
    pub environment: i32,
    /// Configurations of SQL Server and hosts of the cluster.
    #[prost(message, optional, tag = "6")]
    pub config_spec: ::core::option::Option<ConfigSpec>,
    /// One or more configurations of databases to be created in the SQL Server cluster.
    #[prost(message, repeated, tag = "7")]
    pub database_specs: ::prost::alloc::vec::Vec<DatabaseSpec>,
    /// One or more configurations of database users to be created in the SQL Server cluster.
    #[prost(message, repeated, tag = "8")]
    pub user_specs: ::prost::alloc::vec::Vec<UserSpec>,
    /// One or more configurations of hosts to be created in the SQL Server cluster.
    #[prost(message, repeated, tag = "9")]
    pub host_specs: ::prost::alloc::vec::Vec<HostSpec>,
    /// ID of the network to create the SQL Server 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>,
    /// Determines whether the cluster is protected from being deleted.
    #[prost(bool, tag = "12")]
    pub deletion_protection: bool,
    /// Name of SQL Collation that cluster will be created with.
    #[prost(string, tag = "13")]
    pub sqlcollation: ::prost::alloc::string::String,
    /// Host groups hosting VMs of the cluster.
    #[prost(string, repeated, tag = "14")]
    pub host_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// ID of the service account used for access to Object Storage.
    #[prost(string, tag = "15")]
    pub service_account_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateClusterMetadata {
    /// ID of the SQL Server cluster 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 SQL Server cluster to update.
    ///
    /// To get the SQL Server 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 SQL Server cluster should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New description of the SQL Server cluster.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the SQL Server cluster as `key:value` pairs.
    ///
    /// For example, `"project":"mvp"` or `"source":"dictionary"`.
    ///
    /// The new set of labels completely replaces the old one.
    ///
    /// 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 SQL Server cluster.
    #[prost(message, optional, tag = "5")]
    pub config_spec: ::core::option::Option<ConfigSpec>,
    /// New name for the SQL Server cluster.
    #[prost(string, tag = "6")]
    pub name: ::prost::alloc::string::String,
    /// User security groups.
    #[prost(string, repeated, tag = "7")]
    pub security_group_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Determines whether the cluster is protected from being deleted.
    #[prost(bool, tag = "8")]
    pub deletion_protection: bool,
    /// ID of the service account used for access to Object Storage.
    #[prost(string, tag = "9")]
    pub service_account_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateClusterMetadata {
    /// ID of the SQL Server cluster 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 SQL Server cluster to delete.
    ///
    /// To get the SQL Server 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 SQL Server cluster 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 BackupClusterRequest {
    /// ID of the SQL Server cluster to back up.
    ///
    /// To get the SQL Server 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 SQL Server cluster being backed up.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RestoreClusterRequest {
    /// ID of the backup to create a new 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 SQL Server cluster should be restored.
    #[prost(message, optional, tag = "2")]
    pub time: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the new SQL Server cluster to be created from the backup. The name must be unique within the folder.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the new SQL Server cluster to be created from the backup.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Custom labels for the new SQL Server cluster to be created from the backup as `key:value` pairs.
    ///
    /// 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 SQL Server cluster to be created from the backup.
    #[prost(enumeration = "cluster::Environment", tag = "7")]
    pub environment: i32,
    /// Configuration for the new SQL Server cluster to be created from the backup.
    #[prost(message, optional, tag = "8")]
    pub config_spec: ::core::option::Option<ConfigSpec>,
    /// Configurations for SQL Server hosts that should be added to the cluster 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 SQL Server cluster in.
    #[prost(string, tag = "10")]
    pub network_id: ::prost::alloc::string::String,
    /// ID of the folder to create the SQL Server cluster in.
    ///
    /// To get the folder ID, use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[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>,
    /// Determines whether the cluster is protected from being deleted.
    #[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>,
    /// ID of the service account used for access to Object Storage.
    #[prost(string, tag = "15")]
    pub service_account_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RestoreClusterMetadata {
    /// ID of the new SQL Server cluster being created from a backup.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the backup 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 SQL Server cluster.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Host name to switch master role to.
    ///
    /// To get this name, make a \[ClusterService.ListHosts\] request.
    #[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 SQL Server 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 LogRecord {
    /// Log record timestamp.
    #[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 SQL Server cluster to request logs for.
    ///
    /// To get the SQL Server 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,
    /// Specifies a moment that the logs are requested from.
    #[prost(message, optional, tag = "4")]
    pub from_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Specifies a moment that the logs are requested till.
    #[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,
    /// The service returns \[next_page_token\] even if the current page is empty.
    #[prost(bool, tag = "8")]
    pub always_next_page_token: bool,
    /// A filter expression that filters resources listed in the response.
    ///
    /// The expression must specify:
    ///
    /// 1. A field name to filter by. Currently filtering can be applied to the \[LogRecord.logs.message.hostname\] field only.
    /// 2. A conditional operator. Can be either `=` or `!=` for single values, `IN` or `NOT IN` for lists of values.
    /// 3. A value. Must be 1-63 characters long and match the regular expression `\[a-z0-9.-\]{1,61}`.
    ///
    /// Example of a filter: `message.hostname='node1.db.cloud.yandex.net'`.
    ///
    #[prost(string, tag = "9")]
    pub filter: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ListClusterLogsRequest`.
pub mod list_cluster_logs_request {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ServiceType {
        Unspecified = 0,
        /// SQL Server error log.
        SqlserverError = 1,
        /// SQL Server application log.
        SqlserverApplication = 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::SqlserverError => "SQLSERVER_ERROR",
                ServiceType::SqlserverApplication => "SQLSERVER_APPLICATION",
            }
        }
        /// 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),
                "SQLSERVER_ERROR" => Some(Self::SqlserverError),
                "SQLSERVER_APPLICATION" => Some(Self::SqlserverApplication),
                _ => 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>,
    /// Token that 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 has 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 ListClusterOperationsRequest {
    /// ID of the SQL Server cluster to list operations for.
    ///
    /// 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 \[ListClusterOperationsResponse.next_page_token\] that can be used to get the next page of results in subsequent list requests.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the \[ListClusterOperationsResponse.next_page_token\] returned by the previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClusterOperationsResponse {
    /// List of operations for the specified SQL Server cluster.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::super::operation::Operation>,
    /// Token that 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 has 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 SQL Server cluster.
    ///
    /// To get the SQL Server 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 SQL Server backups.
    #[prost(message, repeated, tag = "1")]
    pub backups: ::prost::alloc::vec::Vec<Backup>,
    /// Token that 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 has 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 SQL Server cluster.
    ///
    /// To get the SQL Server 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 SQL Server hosts.
    #[prost(message, repeated, tag = "1")]
    pub hosts: ::prost::alloc::vec::Vec<Host>,
    /// Token that 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 has 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 StartClusterRequest {
    /// ID of the SQL Server cluster to start.
    ///
    /// 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 StartClusterMetadata {
    /// ID of the SQL Server cluster being started.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StopClusterRequest {
    /// ID of the SQL Server cluster to stop.
    ///
    /// 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 StopClusterMetadata {
    /// ID of the SQL Server cluster being stopped.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MoveClusterRequest {
    /// ID of the SQL Server cluster to move.
    ///
    /// To get the cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the destination folder.
    ///
    /// To get the folder ID, use a \[yandex.cloud.resourcemanager.v1.FolderService.List\] request.
    #[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 SQL Server cluster being moved.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// ID of the source folder.
    #[prost(string, tag = "2")]
    pub source_folder_id: ::prost::alloc::string::String,
    /// ID of the destination folder.
    #[prost(string, tag = "3")]
    pub destination_folder_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateClusterHostsMetadata {
    /// ID of the SQL Server cluster to update hosts in.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Names of the hosts 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 HostSpec {
    /// ID of the availability zone where the host resides.
    ///
    /// To get the 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,
    /// Determines whether the host gets 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` - do not assign a public IP to the host;
    /// * `true` - assign a public IP to the host.
    #[prost(bool, tag = "3")]
    pub assign_public_ip: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateHostSpec {
    /// Name of the host to update.
    ///
    /// To get the SQL Server host name, use a \[ClusterService.ListHosts\] request.
    #[prost(string, tag = "1")]
    pub host_name: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the SQL Server host should be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Determines whether the host gets a public IP address on creation.
    #[prost(bool, tag = "3")]
    pub assign_public_ip: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateClusterHostsRequest {
    /// ID of the SQL Server cluster to update hosts in.
    /// To get the SQL Server 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 ConfigSpec {
    /// Version of SQL Server used in the cluster.
    ///
    /// Possible values:
    /// * 2016sp2std,
    /// * 2016sp2ent,
    /// * 2017std,
    /// * 2017ent,
    /// * 2019std,
    /// * 2019ent.
    ///
    /// No formal validation, a list of supported versions should suffice.
    #[prost(string, tag = "1")]
    pub version: ::prost::alloc::string::String,
    /// Resources allocated to SQL Server hosts.
    #[prost(message, optional, tag = "3")]
    pub resources: ::core::option::Option<Resources>,
    /// Start time for the daily backup in UTC timezone.
    ///
    #[prost(message, optional, tag = "4")]
    pub backup_window_start: ::core::option::Option<
        super::super::super::super::super::google::r#type::TimeOfDay,
    >,
    /// Database access policy.
    #[prost(message, optional, tag = "6")]
    pub access: ::core::option::Option<Access>,
    /// Secondary replicas connection mode
    #[prost(enumeration = "cluster_config::SecondaryConnections", tag = "7")]
    pub secondary_connections: i32,
    /// Configuration of an SQL Server cluster.
    #[prost(oneof = "config_spec::SqlserverConfig", tags = "2, 5, 8, 9, 10, 11")]
    pub sqlserver_config: ::core::option::Option<config_spec::SqlserverConfig>,
}
/// Nested message and enum types in `ConfigSpec`.
pub mod config_spec {
    /// Configuration of an SQL Server cluster.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum SqlserverConfig {
        /// Configuration for an SQL Server 2016 SP2 Standard edition cluster.
        #[prost(message, tag = "2")]
        SqlserverConfig2016sp2std(super::config::SqlServerConfig2016sp2std),
        /// Configuration for an SQL Server 2016 SP2 Enterprise edition cluster.
        #[prost(message, tag = "5")]
        SqlserverConfig2016sp2ent(super::config::SqlServerConfig2016sp2ent),
        /// Configuration for an SQL Server 2017 Standard edition cluster.
        #[prost(message, tag = "8")]
        SqlserverConfig2017std(super::config::SqlServerConfig2017std),
        /// Configuration for an SQL Server 2017 Enterprise edition cluster.
        #[prost(message, tag = "9")]
        SqlserverConfig2017ent(super::config::SqlServerConfig2017ent),
        /// Configuration for an SQL Server 2019 Standard edition cluster.
        #[prost(message, tag = "10")]
        SqlserverConfig2019std(super::config::SqlServerConfig2019std),
        /// Configuration for an SQL Server 2019 Enterprise edition cluster.
        #[prost(message, tag = "11")]
        SqlserverConfig2019ent(super::config::SqlServerConfig2019ent),
    }
}
/// 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 SQL Server clusters.
    #[derive(Debug, Clone)]
    pub struct ClusterServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ClusterServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ClusterServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ClusterServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            ClusterServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the specified SQL Server cluster.
        ///
        /// To get the list of available SQL Server clusters, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetClusterRequest>,
        ) -> std::result::Result<tonic::Response<super::Cluster>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.mdb.sqlserver.v1.ClusterService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of SQL Server clusters that belong to the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListClustersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListClustersResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.mdb.sqlserver.v1.ClusterService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an SQL Server 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.sqlserver.v1.ClusterService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Modifies the specified SQL Server 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.sqlserver.v1.ClusterService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified SQL Server 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.sqlserver.v1.ClusterService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Starts the specified SQL Server 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.sqlserver.v1.ClusterService/Start",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "Start",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Stops the specified SQL Server 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.sqlserver.v1.ClusterService/Stop",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "Stop",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Moves the specified SQL Server 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.sqlserver.v1.ClusterService/Move",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "Move",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a backup for the specified SQL Server 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.sqlserver.v1.ClusterService/Backup",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "Backup",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new SQL Server 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.sqlserver.v1.ClusterService/Restore",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "Restore",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Starts a manual failover for a 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.sqlserver.v1.ClusterService/StartFailover",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "StartFailover",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves logs for the specified SQL Server cluster.
        ///
        /// For more information about logs, see the [Logs](/docs/managed-sqlserver/operations/cluster-logs) section in the documentation.
        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.sqlserver.v1.ClusterService/ListLogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "ListLogs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of operations for the specified SQL Server 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.sqlserver.v1.ClusterService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of available backups for the specified SQL Server 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.sqlserver.v1.ClusterService/ListBackups",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "ListBackups",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of hosts for the specified SQL Server 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.sqlserver.v1.ClusterService/ListHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ClusterService",
                        "ListHosts",
                    ),
                );
            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.sqlserver.v1.ClusterService/UpdateHosts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.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 SQL Server cluster 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 SQL Server database to return.
    ///
    /// To get the name of the database use a \[DatabaseService.List\] request.
    #[prost(string, tag = "2")]
    pub database_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListDatabasesRequest {
    /// ID of the SQL Server 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 SQL Server databases.
    #[prost(message, repeated, tag = "1")]
    pub databases: ::prost::alloc::vec::Vec<Database>,
    /// Token that 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 has 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 SQL Server 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 SQL Server cluster where the database is being created.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the SQL Server database being created.
    #[prost(string, tag = "2")]
    pub database_name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteDatabaseRequest {
    /// ID of the SQL Server 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 SQL Server cluster where the database is being deleted.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the SQL Server database being deleted.
    #[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 RestoreDatabaseRequest {
    /// ID of the SQL Server cluster to restore 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 SQL Server database that is being restored.
    #[prost(string, tag = "2")]
    pub database_name: ::prost::alloc::string::String,
    /// Name of the database which backup is used to restore the database.
    #[prost(string, tag = "3")]
    pub from_database: ::prost::alloc::string::String,
    /// ID of a backup to be used.
    #[prost(string, tag = "4")]
    pub backup_id: ::prost::alloc::string::String,
    /// Timestamp which is used for Point-in-Time recovery.
    #[prost(message, optional, tag = "6")]
    pub time: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RestoreDatabaseMetadata {
    /// ID of the SQL Server cluster where a database is being created.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of an SQL Server database that is being created.
    #[prost(string, tag = "2")]
    pub database_name: ::prost::alloc::string::String,
    /// Name of the database which backup is used to restore the database.
    #[prost(string, tag = "3")]
    pub from_database: ::prost::alloc::string::String,
    /// ID of a backup to be used.
    #[prost(string, tag = "4")]
    pub backup_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportDatabaseBackupRequest {
    /// ID of the SQL Server cluster to import 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 SQL Server database that is being imported.
    #[prost(string, tag = "2")]
    pub database_name: ::prost::alloc::string::String,
    /// Name of object storage bucket to import backups from.
    #[prost(string, tag = "3")]
    pub s3_bucket: ::prost::alloc::string::String,
    /// Path in object storage bucket to import backups from.
    #[prost(string, tag = "4")]
    pub s3_path: ::prost::alloc::string::String,
    /// List of .bak files in bucket containing database backup.
    #[prost(string, repeated, tag = "5")]
    pub files: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportDatabaseBackupMetadata {
    /// ID of the SQL Server cluster where a database is being imported.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the SQL Server database that is being imported.
    #[prost(string, tag = "2")]
    pub database_name: ::prost::alloc::string::String,
    /// Name of object storage bucket to import backups from.
    #[prost(string, tag = "3")]
    pub s3_bucket: ::prost::alloc::string::String,
    /// Path in object storage bucket to import backups from.
    #[prost(string, tag = "4")]
    pub s3_path: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExportDatabaseBackupRequest {
    /// ID of the SQL Server cluster to export a database from.
    ///
    /// To get the cluster ID, use a \[ClusterService.List\] request.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the SQL Server database that is being exported.
    #[prost(string, tag = "2")]
    pub database_name: ::prost::alloc::string::String,
    /// Name of object storage bucket to export backups to.
    #[prost(string, tag = "3")]
    pub s3_bucket: ::prost::alloc::string::String,
    /// Path in object storage bucket to export backups to.
    #[prost(string, tag = "4")]
    pub s3_path: ::prost::alloc::string::String,
    /// Prefix for .bak files to export.
    #[prost(string, tag = "5")]
    pub prefix: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExportDatabaseBackupMetadata {
    /// ID of the SQL Server cluster where a database is being exported.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the SQL Server database that is being exported.
    #[prost(string, tag = "2")]
    pub database_name: ::prost::alloc::string::String,
    /// Name of object storage bucket to export backups to.
    #[prost(string, tag = "3")]
    pub s3_bucket: ::prost::alloc::string::String,
    /// Path in object storage bucket to export backups to.
    #[prost(string, tag = "4")]
    pub s3_path: ::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 SQL Server databases.
    #[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 SQL Server database.
        ///
        /// To get the list of available SQL Server databases, 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.sqlserver.v1.DatabaseService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.DatabaseService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of SQL Server databases 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.sqlserver.v1.DatabaseService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.DatabaseService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new SQL Server 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.sqlserver.v1.DatabaseService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.DatabaseService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new SQL Server database in the specified cluster from a backup.
        pub async fn restore(
            &mut self,
            request: impl tonic::IntoRequest<super::RestoreDatabaseRequest>,
        ) -> 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.sqlserver.v1.DatabaseService/Restore",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.DatabaseService",
                        "Restore",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Imports a new SQL Server database from an external backup.
        pub async fn import_backup(
            &mut self,
            request: impl tonic::IntoRequest<super::ImportDatabaseBackupRequest>,
        ) -> 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.sqlserver.v1.DatabaseService/ImportBackup",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.DatabaseService",
                        "ImportBackup",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Exports the last database backup to an external backup.
        pub async fn export_backup(
            &mut self,
            request: impl tonic::IntoRequest<super::ExportDatabaseBackupRequest>,
        ) -> 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.sqlserver.v1.DatabaseService/ExportBackup",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.DatabaseService",
                        "ExportBackup",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified SQL Server 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.sqlserver.v1.DatabaseService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.DatabaseService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A preset of resources for hardware configuration of SQL Server hosts.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResourcePreset {
    /// ID of the resource preset.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// IDs of availability zones where the resource preset is available.
    #[prost(string, repeated, tag = "2")]
    pub zone_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Number of CPU cores for an SQL Server host created with the preset.
    #[prost(int64, tag = "3")]
    pub cores: i64,
    /// RAM volume for an SQL Server 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 resource presets.
    #[prost(message, repeated, tag = "1")]
    pub resource_presets: ::prost::alloc::vec::Vec<ResourcePreset>,
    /// Token that 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 has 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 resource presets.
    #[derive(Debug, Clone)]
    pub struct ResourcePresetServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ResourcePresetServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ResourcePresetServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ResourcePresetServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            ResourcePresetServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Returns the specified resource preset.
        ///
        /// To get the list of available resource presets, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetResourcePresetRequest>,
        ) -> std::result::Result<tonic::Response<super::ResourcePreset>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.mdb.sqlserver.v1.ResourcePresetService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.ResourcePresetService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of available resource presets.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListResourcePresetsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListResourcePresetsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yandex.cloud.mdb.sqlserver.v1.ResourcePresetService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.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 SQL Server 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 SQL Server user to return.
    ///
    /// To get the name of the user use a \[DatabaseService.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 SQL Server 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 {
    /// Requested list of SQL Server users.
    #[prost(message, repeated, tag = "1")]
    pub users: ::prost::alloc::vec::Vec<User>,
    /// Token that 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 has 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 SQL Server cluster to create a user for.
    ///
    /// 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 SQL Server cluster the user is being created for.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the user 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 SQL Server 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 SQL Server user should be updated.
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// New password for the user.
    #[prost(string, tag = "4")]
    pub password: ::prost::alloc::string::String,
    /// New set of permissions for the user.
    #[prost(message, repeated, tag = "5")]
    pub permissions: ::prost::alloc::vec::Vec<Permission>,
    /// New set of server roles granted to the login.
    #[prost(enumeration = "ServerRole", repeated, tag = "6")]
    pub server_roles: ::prost::alloc::vec::Vec<i32>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateUserMetadata {
    /// ID of the SQL Server cluster the user belongs to.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the user 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 SQL Server 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 SQL Server cluster the user belongs to.
    #[prost(string, tag = "1")]
    pub cluster_id: ::prost::alloc::string::String,
    /// Name of the user 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 SQL Server 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 SQL Server 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 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 SQL Server 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,
    /// Permission that should be revoked from 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 RevokeUserPermissionMetadata {
    /// ID of the SQL Server 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 SQL Server users.
    #[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 SQL Server user.
        ///
        /// To get the list of available SQL Server users, 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.sqlserver.v1.UserService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.sqlserver.v1.UserService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves a list of SQL Server users 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.sqlserver.v1.UserService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.mdb.sqlserver.v1.UserService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates an SQL Server 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.sqlserver.v1.UserService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.UserService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Modifies the specified SQL Server 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.sqlserver.v1.UserService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.UserService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified SQL Server 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.sqlserver.v1.UserService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.UserService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Grants a permission to the specified SQL Server 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.sqlserver.v1.UserService/GrantPermission",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.UserService",
                        "GrantPermission",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Revokes a permission from the specified SQL Server 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.sqlserver.v1.UserService/RevokePermission",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.mdb.sqlserver.v1.UserService",
                        "RevokePermission",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}