yandex-cloud 2025.4.14

/// An ApiKey resource. For more information, see \[Api-Key\](/docs/iam/concepts/authorization/api-key).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApiKey {
    /// ID of the API Key.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the service account that the API key belongs to.
    #[prost(string, tag = "2")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Creation timestamp.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Description of the API key. 0-256 characters long.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Timestamp for the last authentication using this API key.
    #[prost(message, optional, tag = "5")]
    pub last_used_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Draft
    /// Scope of the API key. 0-256 characters long.
    #[deprecated]
    #[prost(string, tag = "6")]
    pub scope: ::prost::alloc::string::String,
    /// Scopes of the API key. 0-256 characters long.
    #[prost(string, repeated, tag = "8")]
    pub scopes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// API key expiration timestamp.
    #[prost(message, optional, tag = "7")]
    pub expires_at: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetApiKeyRequest {
    /// ID of the API key to return.
    /// To get the API key ID, use a \[ApiKeyService.List\] request.
    #[prost(string, tag = "1")]
    pub api_key_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListApiKeysRequest {
    /// ID of the service account to list API keys for.
    /// To get the service account ID, use a \[yandex.cloud.iam.v1.ServiceAccountService.List\] request.
    /// If not specified, it defaults to the subject that made the request.
    ///
    /// use current subject identity if this not set
    #[prost(string, tag = "1")]
    pub service_account_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 \[ListApiKeysResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\]
    /// to the \[ListApiKeysResponse.next_page_token\]
    /// returned by a 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 ListApiKeysResponse {
    /// List of API keys.
    #[prost(message, repeated, tag = "1")]
    pub api_keys: ::prost::alloc::vec::Vec<ApiKey>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListApiKeysRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListApiKeysRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateApiKeyRequest {
    /// ID of the service account to create an API key for.
    /// To get the service account ID, use a \[yandex.cloud.iam.v1.ServiceAccountService.List\] request.
    /// If not specified, it defaults to the subject that made the request.
    ///
    /// use current subject identity if this not set
    #[prost(string, tag = "1")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Description of the API key.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Draft
    /// Scope of the API key.
    #[deprecated]
    #[prost(string, tag = "3")]
    pub scope: ::prost::alloc::string::String,
    /// Scopes of the API key.
    #[prost(string, repeated, tag = "5")]
    pub scopes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// API key expiration timestamp, if not specified, then the API key doesn't expire
    #[prost(message, optional, tag = "4")]
    pub expires_at: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateApiKeyResponse {
    /// ApiKey resource.
    #[prost(message, optional, tag = "1")]
    pub api_key: ::core::option::Option<ApiKey>,
    /// Secret part of the API key. This secret key you may use in the requests for authentication.
    #[prost(string, tag = "2")]
    pub secret: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateApiKeyRequest {
    /// ID of the ApiKey resource to update.
    /// To get the API key ID, use a \[ApiKeyService.List\] request.
    #[prost(string, tag = "1")]
    pub api_key_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the ApiKey resource are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Description of the API key.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Scopes of the API key.
    #[prost(string, repeated, tag = "4")]
    pub scopes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// API key expiration timestamp, if not specified, then the API key doesn't expire
    #[prost(message, optional, tag = "5")]
    pub expires_at: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateApiKeyMetadata {
    /// ID of the ApiKey resource that is being updated.
    #[prost(string, tag = "1")]
    pub api_key_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteApiKeyRequest {
    /// ID of the API key to delete.
    /// To get the API key ID, use a \[ApiKeyService.List\] request.
    #[prost(string, tag = "1")]
    pub api_key_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteApiKeyMetadata {
    /// ID of the API key that is being deleted.
    #[prost(string, tag = "1")]
    pub api_key_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListApiKeyOperationsRequest {
    /// ID of the key to list operations for.
    #[prost(string, tag = "1")]
    pub api_key_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 \[ListApiKeyOperationsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the
    /// \[ListApiKeyOperationsResponse.next_page_token\] returned by a 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 ListApiKeyOperationsResponse {
    /// List of operations for the specified API key.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListApiKeyOperationsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListApiKeyOperationsRequest.page_token\] query parameter in the next list request.
    /// Each subsequent list request will have its own \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListApiKeyScopesRequest {
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListApiKeyScopesResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "1")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the
    /// \[ListApiKeyScopesResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "2")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListApiKeyScopesResponse {
    /// List of scopes
    #[prost(string, repeated, tag = "1")]
    pub scopes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListApiKeyScopesRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListApiKeyScopesRequest.page_token\] query parameter in the next list request.
    /// Each subsequent list request will have its own \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod api_key_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 API keys.
    #[derive(Debug, Clone)]
    pub struct ApiKeyServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ApiKeyServiceClient<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> ApiKeyServiceClient<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,
        ) -> ApiKeyServiceClient<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,
        {
            ApiKeyServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Retrieves the list of API keys for the specified service account.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListApiKeysRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListApiKeysResponse>,
            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.iam.v1.ApiKeyService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.iam.v1.ApiKeyService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Returns the specified API key.
        ///
        /// To get the list of available API keys, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetApiKeyRequest>,
        ) -> std::result::Result<tonic::Response<super::ApiKey>, 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.iam.v1.ApiKeyService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.iam.v1.ApiKeyService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Creates an API key for the specified service account.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateApiKeyRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateApiKeyResponse>,
            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.iam.v1.ApiKeyService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.iam.v1.ApiKeyService", "Create"));
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified API key.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateApiKeyRequest>,
        ) -> std::result::Result<
            tonic::Response<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.iam.v1.ApiKeyService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.iam.v1.ApiKeyService", "Update"));
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified API key.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteApiKeyRequest>,
        ) -> std::result::Result<
            tonic::Response<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.iam.v1.ApiKeyService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.iam.v1.ApiKeyService", "Delete"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of operations for the specified API key.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListApiKeyOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListApiKeyOperationsResponse>,
            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.iam.v1.ApiKeyService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.iam.v1.ApiKeyService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of scopes.
        pub async fn list_scopes(
            &mut self,
            request: impl tonic::IntoRequest<super::ListApiKeyScopesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListApiKeyScopesResponse>,
            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.iam.v1.ApiKeyService/ListScopes",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.iam.v1.ApiKeyService", "ListScopes"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateIamTokenRequest {
    #[prost(oneof = "create_iam_token_request::Identity", tags = "1, 2")]
    pub identity: ::core::option::Option<create_iam_token_request::Identity>,
}
/// Nested message and enum types in `CreateIamTokenRequest`.
pub mod create_iam_token_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Identity {
        /// OAuth token for a Yandex account.
        /// For more information, see [OAuth token](/docs/iam/concepts/authorization/oauth-token).
        #[prost(string, tag = "1")]
        YandexPassportOauthToken(::prost::alloc::string::String),
        /// JSON Web Token (JWT) for a service account.
        /// For more information, see [Get IAM token for a service account](/docs/iam/operations/iam-token/create-for-sa).
        #[prost(string, tag = "2")]
        Jwt(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateIamTokenResponse {
    /// IAM token for the specified identity.
    ///
    /// You should pass the token in the `Authorization` header for any further API requests.
    /// For example, `Authorization: Bearer \[iam_token\]`.
    #[prost(string, tag = "1")]
    pub iam_token: ::prost::alloc::string::String,
    /// IAM token expiration time.
    #[prost(message, optional, tag = "2")]
    pub expires_at: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateIamTokenForServiceAccountRequest {
    #[prost(string, tag = "1")]
    pub service_account_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RevokeIamTokenRequest {
    #[prost(string, tag = "1")]
    pub iam_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RevokeIamTokenResponse {
    #[prost(string, tag = "1")]
    pub subject_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod iam_token_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 IAM tokens.
    #[derive(Debug, Clone)]
    pub struct IamTokenServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl IamTokenServiceClient<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> IamTokenServiceClient<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,
        ) -> IamTokenServiceClient<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,
        {
            IamTokenServiceClient::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
        }
        /// Create an IAM token for the specified identity.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateIamTokenRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateIamTokenResponse>,
            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.iam.v1.IamTokenService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.iam.v1.IamTokenService", "Create"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Create an IAM token for service account.
        pub async fn create_for_service_account(
            &mut self,
            request: impl tonic::IntoRequest<
                super::CreateIamTokenForServiceAccountRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::CreateIamTokenResponse>,
            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.iam.v1.IamTokenService/CreateForServiceAccount",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.iam.v1.IamTokenService",
                        "CreateForServiceAccount",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Revoke the IAM token.
        pub async fn revoke(
            &mut self,
            request: impl tonic::IntoRequest<super::RevokeIamTokenRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RevokeIamTokenResponse>,
            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.iam.v1.IamTokenService/Revoke",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.iam.v1.IamTokenService", "Revoke"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A Key resource. For more information, see [Authorized keys](/docs/iam/concepts/authorization/key).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Key {
    /// ID of the Key resource.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Creation timestamp.
    #[prost(message, optional, tag = "4")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Description of the Key resource. 0-256 characters long.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// An algorithm used to generate a key pair of the Key resource.
    #[prost(enumeration = "key::Algorithm", tag = "6")]
    pub key_algorithm: i32,
    /// A public key of the Key resource.
    #[prost(string, tag = "7")]
    pub public_key: ::prost::alloc::string::String,
    /// Timestamp for the last use of this key.
    #[prost(message, optional, tag = "9")]
    pub last_used_at: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(oneof = "key::Subject", tags = "2, 3")]
    pub subject: ::core::option::Option<key::Subject>,
}
/// Nested message and enum types in `Key`.
pub mod key {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Algorithm {
        Unspecified = 0,
        /// RSA with a 2048-bit key size. Default value.
        Rsa2048 = 1,
        /// RSA with a 4096-bit key size.
        Rsa4096 = 2,
    }
    impl Algorithm {
        /// 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 {
                Algorithm::Unspecified => "ALGORITHM_UNSPECIFIED",
                Algorithm::Rsa2048 => "RSA_2048",
                Algorithm::Rsa4096 => "RSA_4096",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ALGORITHM_UNSPECIFIED" => Some(Self::Unspecified),
                "RSA_2048" => Some(Self::Rsa2048),
                "RSA_4096" => Some(Self::Rsa4096),
                _ => None,
            }
        }
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Subject {
        /// ID of the user account that the Key resource belongs to.
        #[prost(string, tag = "2")]
        UserAccountId(::prost::alloc::string::String),
        /// ID of the service account that the Key resource belongs to.
        #[prost(string, tag = "3")]
        ServiceAccountId(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetKeyRequest {
    /// ID of the Key resource to return.
    /// To get the ID use a \[KeyService.List\] request.
    #[prost(string, tag = "1")]
    pub key_id: ::prost::alloc::string::String,
    /// Output format of the key.
    #[prost(enumeration = "KeyFormat", tag = "2")]
    pub format: i32,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListKeysRequest {
    /// Output format of the key.
    #[prost(enumeration = "KeyFormat", tag = "1")]
    pub format: i32,
    /// ID of the service account to list key pairs for.
    /// To get the service account ID, use a \[yandex.cloud.iam.v1.ServiceAccountService.List\] request.
    /// If not specified, it defaults to the subject that made the request.
    #[prost(string, tag = "2")]
    pub service_account_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 \[ListKeysResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "3")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the
    /// \[ListKeysResponse.next_page_token\] returned by a previous list request.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListKeysResponse {
    /// List of Key resources.
    #[prost(message, repeated, tag = "1")]
    pub keys: ::prost::alloc::vec::Vec<Key>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListKeysRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListKeysRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateKeyRequest {
    /// ID of the service account to create a key pair for.
    /// To get the service account ID, use a \[yandex.cloud.iam.v1.ServiceAccountService.List\] request.
    /// If not specified, it defaults to the subject that made the request.
    #[prost(string, tag = "1")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Description of the key pair.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Output format of the key.
    #[prost(enumeration = "KeyFormat", tag = "3")]
    pub format: i32,
    /// An algorithm used to generate a key pair of the Key resource.
    #[prost(enumeration = "key::Algorithm", tag = "4")]
    pub key_algorithm: i32,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateKeyResponse {
    /// Key resource.
    #[prost(message, optional, tag = "1")]
    pub key: ::core::option::Option<Key>,
    /// A private key of the Key resource.
    /// This key must be stored securely.
    #[prost(string, tag = "2")]
    pub private_key: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateKeyRequest {
    /// ID of the Key resource to update.
    /// To get key pair ID, use a \[KeyService.List\] request.
    #[prost(string, tag = "1")]
    pub key_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the Key resource are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Description of the key pair.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateKeyMetadata {
    /// ID of the Key resource that is being updated.
    #[prost(string, tag = "1")]
    pub key_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteKeyRequest {
    /// ID of the key to delete.
    /// To get key ID use a \[KeyService.List\] request.
    #[prost(string, tag = "1")]
    pub key_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteKeyMetadata {
    /// ID of the key that is being deleted.
    #[prost(string, tag = "1")]
    pub key_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListKeyOperationsRequest {
    /// ID of the key to list operations for.
    #[prost(string, tag = "1")]
    pub key_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 \[ListKeyOperationsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\] to the
    /// \[ListKeyOperationsResponse.next_page_token\] returned by a 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 ListKeyOperationsResponse {
    /// List of operations for the specified key.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListKeyOperationsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListKeyOperationsRequest.page_token\] query parameter in the next list request.
    /// Each subsequent list request will have its own \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum KeyFormat {
    /// Privacy-Enhanced Mail (PEM) format. Default value.
    PemFile = 0,
}
impl KeyFormat {
    /// 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 {
            KeyFormat::PemFile => "PEM_FILE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PEM_FILE" => Some(Self::PemFile),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod key_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 Key resources.
    #[derive(Debug, Clone)]
    pub struct KeyServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl KeyServiceClient<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> KeyServiceClient<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,
        ) -> KeyServiceClient<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,
        {
            KeyServiceClient::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 Key resource.
        ///
        /// To get the list of available Key resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetKeyRequest>,
        ) -> std::result::Result<tonic::Response<super::Key>, 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.iam.v1.KeyService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.iam.v1.KeyService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of Key resources for the specified service account.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListKeysRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListKeysResponse>,
            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.iam.v1.KeyService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.iam.v1.KeyService", "List"));
            self.inner.unary(req, path, codec).await
        }
        /// Creates a key pair for the specified service account.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateKeyRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateKeyResponse>,
            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.iam.v1.KeyService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.iam.v1.KeyService", "Create"));
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified key pair.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateKeyRequest>,
        ) -> std::result::Result<
            tonic::Response<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.iam.v1.KeyService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.iam.v1.KeyService", "Update"));
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified key pair.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteKeyRequest>,
        ) -> std::result::Result<
            tonic::Response<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.iam.v1.KeyService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.iam.v1.KeyService", "Delete"));
            self.inner.unary(req, path, codec).await
        }
        /// Lists operations for the specified key.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListKeyOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListKeyOperationsResponse>,
            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.iam.v1.KeyService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.iam.v1.KeyService", "ListOperations"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RefreshToken {
    /// Refresh Token id.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Information about the app for which the Refresh Token was issued.
    #[prost(string, tag = "2")]
    pub client_instance_info: ::prost::alloc::string::String,
    /// The OAuth client identifier for which the Refresh Token was issued.
    #[prost(string, tag = "3")]
    pub client_id: ::prost::alloc::string::String,
    /// The subject identifier for whom the Refresh Token was issued.
    #[prost(string, tag = "4")]
    pub subject_id: ::prost::alloc::string::String,
    /// Refresh token creation time.
    #[prost(message, optional, tag = "5")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Refresh token expiration time.
    #[prost(message, optional, tag = "6")]
    pub expires_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Timestamp for the last authentication using this Refresh Token.
    #[prost(message, optional, tag = "7")]
    pub last_used_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Protection level of the refresh token.
    ///
    /// It shows whether DPOP was used to protect the Refresh Token and and the level of security of the storage used for the DPOP key.
    #[prost(enumeration = "refresh_token::ProtectionLevel", tag = "8")]
    pub protection_level: i32,
}
/// Nested message and enum types in `RefreshToken`.
pub mod refresh_token {
    /// Protection level of the refresh token.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ProtectionLevel {
        Unspecified = 0,
        /// Refresh token without DPOP
        NoProtection = 1,
        /// Refresh token with dpop. The dpop key is not a YubiKey PIV key with required pin/touch policy and attestation.
        InsecureKeyDpop = 2,
        /// Refresh token with dpop. The dpop key is a YubiKey PIV key with required pin/touch policy and attestation.
        SecureKeyDpop = 3,
    }
    impl ProtectionLevel {
        /// 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 {
                ProtectionLevel::Unspecified => "PROTECTION_LEVEL_UNSPECIFIED",
                ProtectionLevel::NoProtection => "NO_PROTECTION",
                ProtectionLevel::InsecureKeyDpop => "INSECURE_KEY_DPOP",
                ProtectionLevel::SecureKeyDpop => "SECURE_KEY_DPOP",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PROTECTION_LEVEL_UNSPECIFIED" => Some(Self::Unspecified),
                "NO_PROTECTION" => Some(Self::NoProtection),
                "INSECURE_KEY_DPOP" => Some(Self::InsecureKeyDpop),
                "SECURE_KEY_DPOP" => Some(Self::SecureKeyDpop),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RevokeRefreshTokenMetadata {
    #[prost(string, tag = "1")]
    pub subject_id: ::prost::alloc::string::String,
    /// Id of revoked Refresh Tokens.
    #[prost(string, repeated, tag = "2")]
    pub refresh_token_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRefreshTokensRequest {
    #[prost(string, tag = "1")]
    pub subject_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 \[ListRefreshTokensResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "4")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\]
    /// to the \[ListRefreshTokensResponse.next_page_token\]
    /// returned by a previous list request.
    #[prost(string, tag = "5")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters refresh tokens listed in the response.
    ///
    /// The expression must specify:
    /// 1. The field name. Currently you can use filtering only on \[RefreshToken.client_instance_info\], \[RefreshToken.client_id\] or \[RefreshToken.protection_level\] fields.
    /// 2. The operator. An `=` operator can be used for all fields. An 'IN' operator can be used for \[RefreshToken.protection_level\].
    /// 3. The value. The value must be in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-zA-Z][_-a-zA-Z0-9]{1,61}[a-z0-9\]`.
    /// Example of a filter: `client_instance_info="clientInstanceInfo" AND protection_level IN ("INSECURE_KEY_DPOP", "SECURE_KEY_DPOP")`.
    ///
    #[prost(string, tag = "6")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRefreshTokensResponse {
    /// List of Refresh Tokens
    #[prost(message, repeated, tag = "1")]
    pub refresh_tokens: ::prost::alloc::vec::Vec<RefreshToken>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListRefreshTokensForSubjectRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListRefreshTokensForSubjectRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Revoke Refresh Token request.
/// If none of the parameters refresh_token_id, refresh_token, or revoke_filter are provided, all Refresh Tokens for the current subject will be revoked.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RevokeRefreshTokenRequest {
    #[prost(oneof = "revoke_refresh_token_request::Filter", tags = "1, 2, 3")]
    pub filter: ::core::option::Option<revoke_refresh_token_request::Filter>,
}
/// Nested message and enum types in `RevokeRefreshTokenRequest`.
pub mod revoke_refresh_token_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Filter {
        /// Identifier of the Refresh Token to be revoked.
        #[prost(string, tag = "1")]
        RefreshTokenId(::prost::alloc::string::String),
        /// The Refresh Token to be revoked.
        #[prost(string, tag = "2")]
        RefreshToken(::prost::alloc::string::String),
        /// The filter for revoking Refresh Token
        #[prost(message, tag = "3")]
        RevokeFilter(super::RevokeFilter),
    }
}
/// The Filter object allows filtering Refresh Tokens that will be revoked.
/// It contains three optional fields.
/// When multiple fields are provided, they are combined using a logical AND operation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RevokeFilter {
    /// The OAuth client identifier for which the Refresh Token was issued.
    #[prost(string, tag = "2")]
    pub client_id: ::prost::alloc::string::String,
    /// The subject identifier for whom the Refresh Token was issued.
    /// If not specified, it defaults to the subject that made the request.
    #[prost(string, tag = "3")]
    pub subject_id: ::prost::alloc::string::String,
    /// Information about the app for which the Refresh Token was issued.
    #[prost(string, tag = "4")]
    pub client_instance_info: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RevokeRefreshTokenResponse {
    /// Id of revoked Refresh Tokens.
    #[prost(string, repeated, tag = "1")]
    pub refresh_token_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Generated client implementations.
pub mod refresh_token_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 Refresh Tokens.
    #[derive(Debug, Clone)]
    pub struct RefreshTokenServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl RefreshTokenServiceClient<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> RefreshTokenServiceClient<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,
        ) -> RefreshTokenServiceClient<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,
        {
            RefreshTokenServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// List subjects Refresh Tokens.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListRefreshTokensRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListRefreshTokensResponse>,
            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.iam.v1.RefreshTokenService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.iam.v1.RefreshTokenService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Revoke Refresh Tokens. Several Refresh Tokens can be revoked by one request.
        pub async fn revoke(
            &mut self,
            request: impl tonic::IntoRequest<super::RevokeRefreshTokenRequest>,
        ) -> std::result::Result<
            tonic::Response<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.iam.v1.RefreshTokenService/Revoke",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.iam.v1.RefreshTokenService", "Revoke"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A Resource. For more information, see \[Resource\](/docs/iam/concepts/access-control/resources-with-access-control).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Resource {
    /// ID of the resource.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// The type of the resource, e.g. resource-manager.folder, billing.account, compute.snapshot, etc.
    #[prost(string, tag = "2")]
    pub r#type: ::prost::alloc::string::String,
}
/// A Role resource. For more information, see \[Roles\](/docs/iam/concepts/access-control/roles).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Role {
    /// ID of the role.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Description of the role. 0-256 characters long.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetRoleRequest {
    /// ID of the Role resource to return.
    /// To get the role ID, use a \[RoleService.List\] request.
    #[prost(string, tag = "1")]
    pub role_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRolesRequest {
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListRolesResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "1")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\]
    /// to the \[ListRolesResponse.next_page_token\]
    /// returned by a previous list request.
    #[prost(string, tag = "2")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters resources listed in the response.
    #[prost(string, tag = "3")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListRolesResponse {
    /// List of Role resources.
    #[prost(message, repeated, tag = "1")]
    pub roles: ::prost::alloc::vec::Vec<Role>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListRolesRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListRolesRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod role_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 Role resources.
    #[derive(Debug, Clone)]
    pub struct RoleServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl RoleServiceClient<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> RoleServiceClient<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,
        ) -> RoleServiceClient<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,
        {
            RoleServiceClient::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 Role resource.
        ///
        /// To get the list of available Role resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetRoleRequest>,
        ) -> std::result::Result<tonic::Response<super::Role>, 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.iam.v1.RoleService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.iam.v1.RoleService", "Get"));
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of Role resources.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListRolesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListRolesResponse>,
            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.iam.v1.RoleService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("yandex.cloud.iam.v1.RoleService", "List"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A ServiceAccount resource. For more information, see [Service accounts](/docs/iam/concepts/users/service-accounts).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServiceAccount {
    /// ID of the service account.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the folder that the service account belongs to.
    #[prost(string, tag = "2")]
    pub folder_id: ::prost::alloc::string::String,
    /// Creation timestamp.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the service account.
    /// The name is unique within the cloud. 3-63 characters long.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the service account. 0-256 characters long.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels as `` key:value `` pairs. Maximum of 64 per resource.
    #[prost(map = "string, string", tag = "6")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Timestamp for the last authentication of this service account.
    #[prost(message, optional, tag = "7")]
    pub last_authenticated_at: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetServiceAccountRequest {
    /// ID of the ServiceAccount resource to return.
    /// To get the service account ID, use a \[ServiceAccountService.List\] request.
    #[prost(string, tag = "1")]
    pub service_account_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListServiceAccountsRequest {
    /// ID of the folder to list service accounts 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 \[ListServiceAccountsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\]
    /// to the \[ListServiceAccountsResponse.next_page_token\]
    /// returned by a previous list request.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters resources listed in the response.
    /// The expression must specify:
    /// 1. The field name. Currently you can use filtering only on the \[ServiceAccount.name\] field.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`). Must be 3-63 characters long and match the regular expression `\[a-z][-a-z0-9]{1,61}[a-z0-9\]`.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListServiceAccountsResponse {
    /// List of ServiceAccount resources.
    #[prost(message, repeated, tag = "1")]
    pub service_accounts: ::prost::alloc::vec::Vec<ServiceAccount>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListServiceAccountsRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListServiceAccountsRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateServiceAccountRequest {
    /// ID of the folder to create a service account 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 service account.
    /// The name must be unique within the cloud.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the service account.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels as `` key:value `` pairs.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::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 CreateServiceAccountMetadata {
    /// ID of the service account that is being created.
    #[prost(string, tag = "1")]
    pub service_account_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateServiceAccountRequest {
    /// ID of the ServiceAccount resource to update.
    /// To get the service account ID, use a \[ServiceAccountService.List\] request.
    #[prost(string, tag = "1")]
    pub service_account_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the ServiceAccount resource are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Name of the service account.
    /// The name must be unique within the cloud.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// Description of the service account.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Resource labels as `` key:value `` pairs.
    #[prost(map = "string, string", tag = "5")]
    pub labels: ::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 UpdateServiceAccountMetadata {
    /// ID of the ServiceAccount resource that is being updated.
    #[prost(string, tag = "1")]
    pub service_account_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteServiceAccountRequest {
    /// ID of the service account to delete.
    /// To get the service account ID, use a \[ServiceAccountService.List\] request.
    #[prost(string, tag = "1")]
    pub service_account_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteServiceAccountMetadata {
    /// ID of the service account that is being deleted.
    #[prost(string, tag = "1")]
    pub service_account_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListServiceAccountOperationsRequest {
    /// ID of the ServiceAccount resource to list operations for.
    #[prost(string, tag = "1")]
    pub service_account_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 \[ListServiceAccountOperationsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\]
    /// to the \[ListServiceAccountOperationsResponse.next_page_token\]
    /// returned by a 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 ListServiceAccountOperationsResponse {
    /// List of operations for the specified service account.
    #[prost(message, repeated, tag = "1")]
    pub operations: ::prost::alloc::vec::Vec<super::super::operation::Operation>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListServiceAccountOperationsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListServiceAccountOperationsRequest.page_token\] query parameter in the next list request.
    /// Each subsequent list request will have its own \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod service_account_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 ServiceAccount resources.
    #[derive(Debug, Clone)]
    pub struct ServiceAccountServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ServiceAccountServiceClient<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> ServiceAccountServiceClient<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,
        ) -> ServiceAccountServiceClient<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,
        {
            ServiceAccountServiceClient::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 ServiceAccount resource.
        ///
        /// To get the list of available ServiceAccount resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetServiceAccountRequest>,
        ) -> std::result::Result<tonic::Response<super::ServiceAccount>, 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.iam.v1.ServiceAccountService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.iam.v1.ServiceAccountService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of ServiceAccount resources in the specified folder.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListServiceAccountsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListServiceAccountsResponse>,
            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.iam.v1.ServiceAccountService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.iam.v1.ServiceAccountService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a service account in the specified folder.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateServiceAccountRequest>,
        ) -> std::result::Result<
            tonic::Response<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.iam.v1.ServiceAccountService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.iam.v1.ServiceAccountService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified service account.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateServiceAccountRequest>,
        ) -> std::result::Result<
            tonic::Response<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.iam.v1.ServiceAccountService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.iam.v1.ServiceAccountService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified service account.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteServiceAccountRequest>,
        ) -> std::result::Result<
            tonic::Response<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.iam.v1.ServiceAccountService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.iam.v1.ServiceAccountService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists access bindings for the specified service account.
        pub async fn list_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::ListAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::access::ListAccessBindingsResponse>,
            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.iam.v1.ServiceAccountService/ListAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.iam.v1.ServiceAccountService",
                        "ListAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sets access bindings for the service account.
        pub async fn set_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::SetAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<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.iam.v1.ServiceAccountService/SetAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.iam.v1.ServiceAccountService",
                        "SetAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates access bindings for the specified service account.
        pub async fn update_access_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::super::super::access::UpdateAccessBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<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.iam.v1.ServiceAccountService/UpdateAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.iam.v1.ServiceAccountService",
                        "UpdateAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists operations for the specified service account.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListServiceAccountOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListServiceAccountOperationsResponse>,
            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.iam.v1.ServiceAccountService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.iam.v1.ServiceAccountService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A Service.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Service {
    /// ID of the service.
    #[prost(string, tag = "1")]
    pub service_id: ::prost::alloc::string::String,
    /// Resource that the service belongs to.
    #[prost(message, optional, tag = "2")]
    pub resource: ::core::option::Option<Resource>,
    /// Time of the last status update of the service.
    #[prost(message, optional, tag = "3")]
    pub updated_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Current status of the service.
    #[prost(enumeration = "service::Status", tag = "4")]
    pub status: 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 Status {
        Unspecified = 0,
        /// The service is enabled.
        Enabled = 1,
        /// The service is paused.
        Paused = 2,
        /// The service is disabled.
        Disabled = 3,
        /// The service is being enabled.
        Enabling = 4,
        /// The service is being resumed.
        Resuming = 5,
        /// The service is being paused.
        Pausing = 6,
        /// The service is being disabled.
        Disabling = 7,
        /// The service is in error state.
        Error = 8,
        /// The service could be auto enabled.
        Default = 9,
    }
    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::Unspecified => "STATUS_UNSPECIFIED",
                Status::Enabled => "ENABLED",
                Status::Paused => "PAUSED",
                Status::Disabled => "DISABLED",
                Status::Enabling => "ENABLING",
                Status::Resuming => "RESUMING",
                Status::Pausing => "PAUSING",
                Status::Disabling => "DISABLING",
                Status::Error => "ERROR",
                Status::Default => "DEFAULT",
            }
        }
        /// 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_UNSPECIFIED" => Some(Self::Unspecified),
                "ENABLED" => Some(Self::Enabled),
                "PAUSED" => Some(Self::Paused),
                "DISABLED" => Some(Self::Disabled),
                "ENABLING" => Some(Self::Enabling),
                "RESUMING" => Some(Self::Resuming),
                "PAUSING" => Some(Self::Pausing),
                "DISABLING" => Some(Self::Disabling),
                "ERROR" => Some(Self::Error),
                "DEFAULT" => Some(Self::Default),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServiceAgent {
    /// ID of the agent service account.
    #[prost(string, tag = "1")]
    pub service_account_id: ::prost::alloc::string::String,
    /// ID of the service.
    #[prost(string, tag = "2")]
    pub service_id: ::prost::alloc::string::String,
    /// ID of the microservice.
    #[prost(string, tag = "3")]
    pub microservice_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetServiceRequest {
    /// ID of the Service.
    #[prost(string, tag = "1")]
    pub service_id: ::prost::alloc::string::String,
    /// Resource container to get a service information in.
    ///
    /// It is supported only resource-manager.cloud resource container now.
    #[prost(message, optional, tag = "2")]
    pub resource: ::core::option::Option<Resource>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListServicesRequest {
    /// Resource container to list a services.
    ///
    /// It is supported only resource-manager.cloud resource container now.
    #[prost(message, optional, tag = "1")]
    pub resource: ::core::option::Option<Resource>,
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListServicesResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Default value: 100
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. To get the next page of results, set \[page_token\]
    /// to the \[ListServicesResponse.next_page_token\]
    /// returned by a 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 ListServicesResponse {
    /// List of Services.
    #[prost(message, repeated, tag = "1")]
    pub services: ::prost::alloc::vec::Vec<Service>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListServicesRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListServicesRequest.page_token\] query parameter
    /// in the next list request. Each subsequent list request will have its own
    /// \[next_page_token\] to continue paging through the results.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EnableServiceRequest {
    /// ID of the Service.
    #[prost(string, tag = "1")]
    pub service_id: ::prost::alloc::string::String,
    /// Resource container to enable a service in.
    ///
    /// It is supported only resource-manager.cloud resource container now.
    #[prost(message, optional, tag = "2")]
    pub resource: ::core::option::Option<Resource>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EnableServiceMetadata {
    /// ID of the Service.
    #[prost(string, tag = "1")]
    pub service_id: ::prost::alloc::string::String,
    /// Resource container.
    #[prost(message, optional, tag = "2")]
    pub resource: ::core::option::Option<Resource>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DisableServiceRequest {
    /// ID of the Service.
    #[prost(string, tag = "1")]
    pub service_id: ::prost::alloc::string::String,
    /// Resource container to disable a service in.
    ///
    /// It is supported only resource-manager.cloud resource container now.
    #[prost(message, optional, tag = "2")]
    pub resource: ::core::option::Option<Resource>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DisableServiceMetadata {
    /// ID of the Service.
    #[prost(string, tag = "1")]
    pub service_id: ::prost::alloc::string::String,
    /// Resource container.
    #[prost(message, optional, tag = "2")]
    pub resource: ::core::option::Option<Resource>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResolveServiceAgentRequest {
    /// ID of the Service.
    #[prost(string, tag = "1")]
    pub service_id: ::prost::alloc::string::String,
    /// ID of the Microservice.
    #[prost(string, tag = "2")]
    pub microservice_id: ::prost::alloc::string::String,
    /// Resource container.
    #[prost(message, optional, tag = "3")]
    pub resource: ::core::option::Option<Resource>,
}
/// Generated client implementations.
pub mod service_control_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 Service resources.
    #[derive(Debug, Clone)]
    pub struct ServiceControlServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ServiceControlServiceClient<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> ServiceControlServiceClient<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,
        ) -> ServiceControlServiceClient<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,
        {
            ServiceControlServiceClient::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 Service information in the specified resource container.
        ///
        /// To get the list of available Services, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetServiceRequest>,
        ) -> std::result::Result<tonic::Response<super::Service>, 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.iam.v1.ServiceControlService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.iam.v1.ServiceControlService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of Service in the specified resource container.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListServicesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListServicesResponse>,
            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.iam.v1.ServiceControlService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.iam.v1.ServiceControlService", "List"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Enable a service in the specified resource container.
        pub async fn enable(
            &mut self,
            request: impl tonic::IntoRequest<super::EnableServiceRequest>,
        ) -> std::result::Result<
            tonic::Response<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.iam.v1.ServiceControlService/Enable",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.iam.v1.ServiceControlService",
                        "Enable",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Disable a service in the specified resource container.
        pub async fn disable(
            &mut self,
            request: impl tonic::IntoRequest<super::DisableServiceRequest>,
        ) -> std::result::Result<
            tonic::Response<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.iam.v1.ServiceControlService/Disable",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.iam.v1.ServiceControlService",
                        "Disable",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Resolve agent service account for the service in the specified resource container.
        pub async fn resolve_agent(
            &mut self,
            request: impl tonic::IntoRequest<super::ResolveServiceAgentRequest>,
        ) -> std::result::Result<tonic::Response<super::ServiceAgent>, 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.iam.v1.ServiceControlService/ResolveAgent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.iam.v1.ServiceControlService",
                        "ResolveAgent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Currently represents only [Yandex account](/docs/iam/concepts/users/accounts#passport).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UserAccount {
    /// ID of the user account.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "4")]
    pub last_authenticated_at: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(oneof = "user_account::UserAccount", tags = "2, 3")]
    pub user_account: ::core::option::Option<user_account::UserAccount>,
}
/// Nested message and enum types in `UserAccount`.
pub mod user_account {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum UserAccount {
        /// A YandexPassportUserAccount resource.
        #[prost(message, tag = "2")]
        YandexPassportUserAccount(super::YandexPassportUserAccount),
        /// A SAML federated user.
        #[prost(message, tag = "3")]
        SamlUserAccount(super::SamlUserAccount),
    }
}
/// A YandexPassportUserAccount resource.
/// For more information, see [Yandex account](/docs/iam/concepts/users/accounts#passport).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct YandexPassportUserAccount {
    /// Login of the Yandex user account.
    #[prost(string, tag = "1")]
    pub login: ::prost::alloc::string::String,
    /// Default email of the Yandex user account.
    #[prost(string, tag = "2")]
    pub default_email: ::prost::alloc::string::String,
}
/// A SAML federated user.
/// For more information, see \[federations\](/docs/iam/concepts/federations).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SamlUserAccount {
    /// ID of the federation that the federation belongs to.
    #[prost(string, tag = "1")]
    pub federation_id: ::prost::alloc::string::String,
    /// Name Id of the SAML federated user.
    /// The name is unique within the federation. 1-256 characters long.
    #[prost(string, tag = "2")]
    pub name_id: ::prost::alloc::string::String,
    /// Additional attributes of the SAML federated user.
    #[prost(map = "string, message", tag = "3")]
    pub attributes: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        saml_user_account::Attribute,
    >,
}
/// Nested message and enum types in `SamlUserAccount`.
pub mod saml_user_account {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Attribute {
        #[prost(string, repeated, tag = "1")]
        pub value: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetUserAccountRequest {
    /// ID of the UserAccount resource to return.
    #[prost(string, tag = "1")]
    pub user_account_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod user_account_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 user accounts. Currently applicable only for [Yandex accounts](/docs/iam/concepts/users/accounts#passport).
    #[derive(Debug, Clone)]
    pub struct UserAccountServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl UserAccountServiceClient<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> UserAccountServiceClient<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,
        ) -> UserAccountServiceClient<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,
        {
            UserAccountServiceClient::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 UserAccount resource.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetUserAccountRequest>,
        ) -> std::result::Result<tonic::Response<super::UserAccount>, 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.iam.v1.UserAccountService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("yandex.cloud.iam.v1.UserAccountService", "Get"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetUserAccountByLoginRequest {
    /// Login of the YandexPassportUserAccount resource to return.
    #[prost(string, tag = "1")]
    pub login: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod yandex_passport_user_account_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 YandexPassportUserAccount resources.
    #[derive(Debug, Clone)]
    pub struct YandexPassportUserAccountServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl YandexPassportUserAccountServiceClient<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> YandexPassportUserAccountServiceClient<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,
        ) -> YandexPassportUserAccountServiceClient<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,
        {
            YandexPassportUserAccountServiceClient::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 YandexPassportUserAccount resource.
        pub async fn get_by_login(
            &mut self,
            request: impl tonic::IntoRequest<super::GetUserAccountByLoginRequest>,
        ) -> std::result::Result<tonic::Response<super::UserAccount>, 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.iam.v1.YandexPassportUserAccountService/GetByLogin",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.iam.v1.YandexPassportUserAccountService",
                        "GetByLogin",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}