yandex-cloud 2025.4.14

/// A Group resource.
/// For more information, see \[Groups\](/docs/organization/operations/manage-groups).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Group {
    /// ID of the group.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// ID of the organization that the group belongs to.
    #[prost(string, tag = "2")]
    pub organization_id: ::prost::alloc::string::String,
    /// Creation timestamp.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the group.
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    /// Description of the group.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
}
/// Group mapping represents which external (federated) groups should match which internal (cloud) groups
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GroupMappingItem {
    /// External group id (received from identity provider)
    #[prost(string, tag = "1")]
    pub external_group_id: ::prost::alloc::string::String,
    /// Internal cloud group id
    #[prost(string, tag = "2")]
    pub internal_group_id: ::prost::alloc::string::String,
}
/// Group synchronization status for a specific federation
/// Absence of this object for a federation means that there is no group synchronization set of for the federation.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GroupMapping {
    /// Federation id
    #[prost(string, tag = "1")]
    pub federation_id: ::prost::alloc::string::String,
    /// Flag to show whether group synchronization should be enabled for this federation.
    #[prost(bool, tag = "2")]
    pub enabled: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetGroupMappingRequest {
    #[prost(string, tag = "1")]
    pub federation_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetGroupMappingResponse {
    #[prost(message, optional, tag = "1")]
    pub group_mapping: ::core::option::Option<GroupMapping>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateGroupMappingRequest {
    /// Federation the group mapping will be created for
    #[prost(string, tag = "1")]
    pub federation_id: ::prost::alloc::string::String,
    /// Synchronization status.
    #[prost(bool, tag = "3")]
    pub enabled: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateGroupMappingMetadata {
    #[prost(string, tag = "1")]
    pub federation_id: ::prost::alloc::string::String,
}
/// Request for updating group mapping configuration
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGroupMappingRequest {
    /// Federation the group mapping update is requested
    #[prost(string, tag = "1")]
    pub federation_id: ::prost::alloc::string::String,
    /// A set of fields that should be updated
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// A new state of synchronization to update (if mentioned in update_mask).
    #[prost(bool, tag = "3")]
    pub enabled: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGroupMappingMetadata {
    #[prost(string, tag = "1")]
    pub federation_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteGroupMappingRequest {
    /// Federation the group mapping deletion is requested
    #[prost(string, tag = "1")]
    pub federation_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteGroupMappingMetadata {
    #[prost(string, tag = "1")]
    pub federation_id: ::prost::alloc::string::String,
}
/// Request for updating group mapping configuration
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGroupMappingItemsRequest {
    /// Federation the group mapping update is requested
    #[prost(string, tag = "1")]
    pub federation_id: ::prost::alloc::string::String,
    /// A collection of mapping items to add or remove (ignores update_fields).
    #[prost(message, repeated, tag = "4")]
    pub group_mapping_item_deltas: ::prost::alloc::vec::Vec<GroupMappingItemDelta>,
}
/// Message describes the user's request to change (add or remove) a single group mapping.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GroupMappingItemDelta {
    #[prost(message, optional, tag = "1")]
    pub item: ::core::option::Option<GroupMappingItem>,
    #[prost(enumeration = "group_mapping_item_delta::Action", tag = "2")]
    pub action: i32,
}
/// Nested message and enum types in `GroupMappingItemDelta`.
pub mod group_mapping_item_delta {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Action {
        Unspecified = 0,
        /// Group mapping item is to be added
        Add = 1,
        /// Group mapping item is to be removed
        Remove = 2,
    }
    impl Action {
        /// 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 {
                Action::Unspecified => "ACTION_UNSPECIFIED",
                Action::Add => "ADD",
                Action::Remove => "REMOVE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ACTION_UNSPECIFIED" => Some(Self::Unspecified),
                "ADD" => Some(Self::Add),
                "REMOVE" => Some(Self::Remove),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGroupMappingItemsMetadata {
    #[prost(string, tag = "1")]
    pub federation_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGroupMappingItemsResponse {
    /// Effective changes that were applied
    #[prost(message, repeated, tag = "4")]
    pub group_mapping_item_deltas: ::prost::alloc::vec::Vec<GroupMappingItemDelta>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListGroupMappingItemsRequest {
    #[prost(string, tag = "1")]
    pub federation_id: ::prost::alloc::string::String,
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListGroupMappingItemsResponse {
    #[prost(message, repeated, tag = "1")]
    pub group_mapping_items: ::prost::alloc::vec::Vec<GroupMappingItem>,
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod group_mapping_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// RPC service dedicated for federation group mapping.
    #[derive(Debug, Clone)]
    pub struct GroupMappingServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl GroupMappingServiceClient<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> GroupMappingServiceClient<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,
        ) -> GroupMappingServiceClient<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,
        {
            GroupMappingServiceClient::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 a group mapping configured for the specific federation
        /// If a federation does not exist this call will return an error
        ///    NOT_FOUND will be returned
        /// If a federation exist, but has not ever been configured for group mapping
        ///   the call FAILED_PRECONDITION will be returned.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetGroupMappingRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetGroupMappingResponse>,
            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.organizationmanager.v1.GroupMappingService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupMappingService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Adds a group mapping for a federation
        /// If mapping already exist, ALREADY_EXISTS will be returned
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateGroupMappingRequest>,
        ) -> 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.organizationmanager.v1.GroupMappingService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupMappingService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an existing group mapping for a federation
        /// Errors:
        /// - if federation is not found
        /// In case of any error, no changes are applied to existing group mapping
        ///
        /// This call is idempotent. The following actions do nothing:
        /// - enabling when already enabled
        /// - disabling when disabled
        /// Such parts of request will be ignored. Others will be applied.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateGroupMappingRequest>,
        ) -> 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.organizationmanager.v1.GroupMappingService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupMappingService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a group mapping. This will remove all the mapping items
        /// cascade.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteGroupMappingRequest>,
        ) -> 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.organizationmanager.v1.GroupMappingService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupMappingService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns all the group mappings items
        ///
        /// Filtering is only supported by external_group_id or internal_group_id
        pub async fn list_items(
            &mut self,
            request: impl tonic::IntoRequest<super::ListGroupMappingItemsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListGroupMappingItemsResponse>,
            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.organizationmanager.v1.GroupMappingService/ListItems",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupMappingService",
                        "ListItems",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates group mapping items for a specified federation
        /// Errors:
        /// - if federation is not found
        /// - if internal group in the mapping added does not exist
        /// In case of any error, no changes are applied to existing group mapping
        ///
        /// This call is idempotent. The following actions do nothing:
        /// - adding group mapping items that are already present
        /// - removing group mapping items that are not present
        /// Such parts of request will be ignored. Others will be applied.
        pub async fn update_items(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateGroupMappingItemsRequest>,
        ) -> 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.organizationmanager.v1.GroupMappingService/UpdateItems",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupMappingService",
                        "UpdateItems",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetGroupRequest {
    /// ID of the Group resource to return.
    /// To get the group ID, use a \[GroupService.List\] request.
    #[prost(string, tag = "1")]
    pub group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListGroupsRequest {
    /// ID of the organization to list groups in.
    /// To get the organization ID, use a \[yandex.cloud.organizationmanager.v1.OrganizationService.List\] request.
    #[prost(string, tag = "1")]
    pub organization_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 \[ListGroupsResponse.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. Set \[page_token\]
    /// to the \[ListGroupsResponse.next_page_token\]
    /// returned by a previous list request to get the next page of results.
    #[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 \[Group.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 ListGroupsResponse {
    /// List of Group resources.
    #[prost(message, repeated, tag = "1")]
    pub groups: ::prost::alloc::vec::Vec<Group>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListGroupsRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListGroupsRequest.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 CreateGroupRequest {
    /// ID of the organization to create a group in.
    /// To get the organization ID, use a \[yandex.cloud.organizationmanager.v1.OrganizationService.List\] request.
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
    /// Name of the group.
    /// The name must be unique within the organization.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// Description of the group.
    #[prost(string, tag = "3")]
    pub description: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateGroupMetadata {
    /// ID of the group that is being created.
    #[prost(string, tag = "1")]
    pub group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGroupRequest {
    /// ID of the Group resource to update.
    /// To get the group ID, use a \[GroupService.List\] request.
    #[prost(string, tag = "1")]
    pub group_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the Group resource are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Name of the group.
    /// The name must be unique within the organization.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// Description of the group.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGroupMetadata {
    /// ID of the Group resource that is being updated.
    #[prost(string, tag = "1")]
    pub group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteGroupRequest {
    /// ID of the group to delete.
    /// To get the group ID, use a \[GroupService.List\] request.
    #[prost(string, tag = "1")]
    pub group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteGroupMetadata {
    /// ID of the group that is being deleted.
    #[prost(string, tag = "1")]
    pub group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListGroupOperationsRequest {
    /// ID of the Group resource to list operations for.
    #[prost(string, tag = "1")]
    pub group_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 \[ListGroupOperationsResponse.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. Set \[page_token\]
    /// to the \[ListGroupOperationsResponse.next_page_token\]
    /// returned by a previous list request to get the next page of results.
    #[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 ListGroupOperationsResponse {
    /// List of operations for the specified group.
    #[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 \[ListGroupOperationsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListGroupOperationsRequest.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 ListGroupMembersRequest {
    /// ID of the Group resource to list members for.
    #[prost(string, tag = "1")]
    pub group_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 \[ListGroupMembersResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Acceptable values are 0 to 1000, inclusive. Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. Set \[page_token\]
    /// to the \[ListGroupMembersResponse.next_page_token\]
    /// returned by a previous list request to get the next page of results.
    #[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 ListGroupMembersResponse {
    /// List of members for the specified group.
    #[prost(message, repeated, tag = "1")]
    pub members: ::prost::alloc::vec::Vec<GroupMember>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListGroupMembersRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListGroupMembersRequest.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 GroupMember {
    /// ID of the subject.
    #[prost(string, tag = "1")]
    pub subject_id: ::prost::alloc::string::String,
    /// Type of the subject.
    ///
    /// It can contain one of the following values:
    /// * `userAccount`: An account on Yandex, added to Yandex Cloud.
    /// * `federatedUser`: A federated account. This type represents a user from an identity federation, like Active Directory.
    #[prost(string, tag = "2")]
    pub subject_type: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGroupMembersRequest {
    /// ID of the group to update.
    /// To get the group ID, use a \[GroupService.List\] request.
    #[prost(string, tag = "1")]
    pub group_id: ::prost::alloc::string::String,
    /// Updates to group members.
    #[prost(message, repeated, tag = "2")]
    pub member_deltas: ::prost::alloc::vec::Vec<MemberDelta>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateGroupMembersMetadata {
    /// ID of the group that is being updated.
    #[prost(string, tag = "1")]
    pub group_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MemberDelta {
    /// The action that is being performed on a group member.
    #[prost(enumeration = "member_delta::MemberAction", tag = "1")]
    pub action: i32,
    /// ID of the subject that is being added or removed from a group.
    ///
    /// Subject type can be one of following values:
    /// * `userAccount`: An account on Yandex, added to Yandex Cloud.
    /// * `federatedUser`: A federated account. This type represents a user from an identity federation, like Active Directory.
    #[prost(string, tag = "2")]
    pub subject_id: ::prost::alloc::string::String,
}
/// Nested message and enum types in `MemberDelta`.
pub mod member_delta {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum MemberAction {
        Unspecified = 0,
        /// Addition of a group member.
        Add = 1,
        /// Removal of a group member.
        Remove = 2,
    }
    impl MemberAction {
        /// 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 {
                MemberAction::Unspecified => "MEMBER_ACTION_UNSPECIFIED",
                MemberAction::Add => "ADD",
                MemberAction::Remove => "REMOVE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MEMBER_ACTION_UNSPECIFIED" => Some(Self::Unspecified),
                "ADD" => Some(Self::Add),
                "REMOVE" => Some(Self::Remove),
                _ => None,
            }
        }
    }
}
/// Generated client implementations.
pub mod group_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 groups.
    #[derive(Debug, Clone)]
    pub struct GroupServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl GroupServiceClient<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> GroupServiceClient<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,
        ) -> GroupServiceClient<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,
        {
            GroupServiceClient::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 Group resource.
        ///
        /// To get the list of available Group resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetGroupRequest>,
        ) -> std::result::Result<tonic::Response<super::Group>, 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.organizationmanager.v1.GroupService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of group resources.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListGroupsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListGroupsResponse>,
            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.organizationmanager.v1.GroupService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a group in the specified organization.
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateGroupRequest>,
        ) -> 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.organizationmanager.v1.GroupService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified group.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateGroupRequest>,
        ) -> 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.organizationmanager.v1.GroupService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the specified group.
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteGroupRequest>,
        ) -> 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.organizationmanager.v1.GroupService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists operations for the specified group.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListGroupOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListGroupOperationsResponse>,
            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.organizationmanager.v1.GroupService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// List group active members.
        pub async fn list_members(
            &mut self,
            request: impl tonic::IntoRequest<super::ListGroupMembersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListGroupMembersResponse>,
            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.organizationmanager.v1.GroupService/ListMembers",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupService",
                        "ListMembers",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Update group members.
        pub async fn update_members(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateGroupMembersRequest>,
        ) -> 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.organizationmanager.v1.GroupService/UpdateMembers",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupService",
                        "UpdateMembers",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists access bindings for the specified group.
        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.organizationmanager.v1.GroupService/ListAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupService",
                        "ListAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sets access bindings for the specified group.
        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.organizationmanager.v1.GroupService/SetAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupService",
                        "SetAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates access bindings for the specified group.
        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.organizationmanager.v1.GroupService/UpdateAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.GroupService",
                        "UpdateAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// An Organization resource. For more information, see \[Organization\](/docs/organization/enable-org).
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Organization {
    /// ID of the organization.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// Creation timestamp.
    #[prost(message, optional, tag = "2")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Name of the organization. 3-63 characters long.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// Description of the organization. 0-256 characters long.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Display name of the organization. 0-256 characters long.
    #[prost(string, tag = "6")]
    pub title: ::prost::alloc::string::String,
    /// Resource labels as `` key:value `` pairs. Maximum of 64 per resource.
    #[prost(map = "string, string", tag = "7")]
    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 GetOrganizationRequest {
    /// ID of the Organization resource to return.
    /// To get the organization ID, use a \[OrganizationService.List\] request.
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOrganizationsRequest {
    /// The maximum number of results per page to return. If the number of available
    /// results is larger than \[page_size\],
    /// the service returns a \[ListOrganizationsResponse.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. Set \[page_token\]
    /// to the \[ListOrganizationsResponse.next_page_token\]
    /// returned by a previous list request to get the next page of results.
    #[prost(string, tag = "2")]
    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 \[Organization.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 = "3")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOrganizationsResponse {
    /// List of Organization resources.
    #[prost(message, repeated, tag = "1")]
    pub organizations: ::prost::alloc::vec::Vec<Organization>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListOrganizationsRequest.page_size\], use
    /// the \[next_page_token\] as the value
    /// for the \[ListOrganizationsRequest.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 UpdateOrganizationRequest {
    /// ID of the organization to update.
    /// To get the organization ID, use a \[OrganizationService.List\] request.
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
    /// Field mask that specifies which fields of the organization are going to be updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Name of the organization.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// Description of the organization.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Display name of the organization.
    #[prost(string, tag = "5")]
    pub title: ::prost::alloc::string::String,
    /// Resource labels as `` key:value `` pairs.
    #[prost(map = "string, string", tag = "6")]
    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 UpdateOrganizationMetadata {
    /// ID of the organization that is being updated.
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOrganizationOperationsRequest {
    /// ID of the Organization resource to list operations for.
    #[prost(string, tag = "1")]
    pub organization_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 \[ListOrganizationOperationsResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Acceptable values are 0 to 1000, inclusive. Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. Set \[page_token\]
    /// to the \[ListOrganizationOperationsResponse.next_page_token\]
    /// returned by a previous list request to get the next page of results.
    #[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 ListOrganizationOperationsResponse {
    /// List of operations for the specified organization.
    #[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 \[ListOrganizationOperationsRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListOrganizationOperationsRequest.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 organization_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 Organization resources.
    #[derive(Debug, Clone)]
    pub struct OrganizationServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl OrganizationServiceClient<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> OrganizationServiceClient<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,
        ) -> OrganizationServiceClient<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,
        {
            OrganizationServiceClient::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 Organization resource.
        ///
        /// To get the list of available Organization resources, make a [List] request.
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetOrganizationRequest>,
        ) -> std::result::Result<tonic::Response<super::Organization>, 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.organizationmanager.v1.OrganizationService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OrganizationService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Retrieves the list of Organization resources.
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListOrganizationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListOrganizationsResponse>,
            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.organizationmanager.v1.OrganizationService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OrganizationService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the specified organization.
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateOrganizationRequest>,
        ) -> 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.organizationmanager.v1.OrganizationService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OrganizationService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists operations for the specified organization.
        pub async fn list_operations(
            &mut self,
            request: impl tonic::IntoRequest<super::ListOrganizationOperationsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListOrganizationOperationsResponse>,
            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.organizationmanager.v1.OrganizationService/ListOperations",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OrganizationService",
                        "ListOperations",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists access bindings for the specified organization.
        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.organizationmanager.v1.OrganizationService/ListAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OrganizationService",
                        "ListAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sets access bindings for the specified organization.
        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.organizationmanager.v1.OrganizationService/SetAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OrganizationService",
                        "SetAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates access bindings for the specified organization.
        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.organizationmanager.v1.OrganizationService/UpdateAccessBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OrganizationService",
                        "UpdateAccessBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetOsLoginSettingsRequest {
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OsLoginSettings {
    #[prost(message, optional, tag = "1")]
    pub user_ssh_key_settings: ::core::option::Option<UserSshKeySettings>,
    #[prost(message, optional, tag = "2")]
    pub ssh_certificate_settings: ::core::option::Option<SshCertificateSettings>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UserSshKeySettings {
    #[prost(bool, tag = "1")]
    pub enabled: bool,
    #[prost(bool, tag = "2")]
    pub allow_manage_own_keys: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SshCertificateSettings {
    #[prost(bool, tag = "1")]
    pub enabled: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateOsLoginSettingsRequest {
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub user_ssh_key_settings: ::core::option::Option<
        update_os_login_settings_request::UserSshKeySettings,
    >,
    #[prost(message, optional, tag = "3")]
    pub ssh_certificate_settings: ::core::option::Option<
        update_os_login_settings_request::SshCertificateSettings,
    >,
    #[prost(message, optional, tag = "4")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Nested message and enum types in `UpdateOsLoginSettingsRequest`.
pub mod update_os_login_settings_request {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct UserSshKeySettings {
        #[prost(bool, tag = "1")]
        pub enabled: bool,
        #[prost(bool, tag = "2")]
        pub allow_manage_own_keys: bool,
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SshCertificateSettings {
        #[prost(bool, tag = "1")]
        pub enabled: bool,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetDefaultOsLoginProfileRequest {
    #[prost(string, tag = "1")]
    pub os_login_profile_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetOsLoginProfileRequest {
    #[prost(string, tag = "1")]
    pub os_login_profile_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOsLoginProfilesRequest {
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// A filter expression that filters profiles listed in the response.
    /// The expression must specify:
    /// 1. The field name. Currently you can use filtering by subject_id, uid or login.
    /// 2. An `=` operator.
    /// 3. The value in double quotes (`"`).
    /// E.g. login="example-login"
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOsLoginProfilesResponse {
    #[prost(message, repeated, tag = "1")]
    pub profiles: ::prost::alloc::vec::Vec<OsLoginProfile>,
    #[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 OsLoginProfile {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub organization_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub subject_id: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub login: ::prost::alloc::string::String,
    #[prost(int64, tag = "5")]
    pub uid: i64,
    #[prost(bool, tag = "6")]
    pub is_default: bool,
    #[prost(string, tag = "7")]
    pub home_directory: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub shell: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateOsLoginProfileRequest {
    #[prost(string, tag = "1")]
    pub os_login_profile_id: ::prost::alloc::string::String,
    /// must not contain . or end in ~
    #[prost(string, tag = "2")]
    pub login: ::prost::alloc::string::String,
    /// 1000 - 2^63 - 1
    #[prost(int64, tag = "3")]
    pub uid: i64,
    #[prost(string, tag = "4")]
    pub home_directory: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub shell: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "6")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteOsLoginProfileRequest {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateOsLoginProfileRequest {
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub subject_id: ::prost::alloc::string::String,
    /// must not contain . or end in ~
    #[prost(string, tag = "3")]
    pub login: ::prost::alloc::string::String,
    /// 1000 - 2^63 - 1
    #[prost(int64, tag = "4")]
    pub uid: i64,
    #[prost(string, tag = "5")]
    pub home_directory: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub shell: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateOsLoginProfileMetadata {
    #[prost(string, tag = "1")]
    pub os_login_profile_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteOsLoginProfileMetadata {
    #[prost(string, tag = "1")]
    pub os_login_profile_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateOsLoginProfileMetadata {
    #[prost(string, tag = "1")]
    pub os_login_profile_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub organization_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub subject_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateOsLoginSettingsMetadata {
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetDefaultOsLoginProfileMetadata {
    #[prost(string, tag = "1")]
    pub previous_default_profile_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub current_default_profile_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod os_login_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct OsLoginServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl OsLoginServiceClient<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> OsLoginServiceClient<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,
        ) -> OsLoginServiceClient<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,
        {
            OsLoginServiceClient::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
        }
        /// OsLogin settings
        pub async fn get_settings(
            &mut self,
            request: impl tonic::IntoRequest<super::GetOsLoginSettingsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::OsLoginSettings>,
            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.organizationmanager.v1.OsLoginService/GetSettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OsLoginService",
                        "GetSettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn update_settings(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateOsLoginSettingsRequest>,
        ) -> 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.organizationmanager.v1.OsLoginService/UpdateSettings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OsLoginService",
                        "UpdateSettings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// OsLogin Profiles
        pub async fn get_profile(
            &mut self,
            request: impl tonic::IntoRequest<super::GetOsLoginProfileRequest>,
        ) -> std::result::Result<tonic::Response<super::OsLoginProfile>, 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.organizationmanager.v1.OsLoginService/GetProfile",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OsLoginService",
                        "GetProfile",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn list_profiles(
            &mut self,
            request: impl tonic::IntoRequest<super::ListOsLoginProfilesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListOsLoginProfilesResponse>,
            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.organizationmanager.v1.OsLoginService/ListProfiles",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OsLoginService",
                        "ListProfiles",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn create_profile(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateOsLoginProfileRequest>,
        ) -> 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.organizationmanager.v1.OsLoginService/CreateProfile",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OsLoginService",
                        "CreateProfile",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn update_profile(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateOsLoginProfileRequest>,
        ) -> 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.organizationmanager.v1.OsLoginService/UpdateProfile",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OsLoginService",
                        "UpdateProfile",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Sets a profile as a default for the subject assigned to this profile
        pub async fn set_default_profile(
            &mut self,
            request: impl tonic::IntoRequest<super::SetDefaultOsLoginProfileRequest>,
        ) -> 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.organizationmanager.v1.OsLoginService/SetDefaultProfile",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OsLoginService",
                        "SetDefaultProfile",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn delete_profile(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteOsLoginProfileRequest>,
        ) -> 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.organizationmanager.v1.OsLoginService/DeleteProfile",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.OsLoginService",
                        "DeleteProfile",
                    ),
                );
            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(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/users/saml-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 GenerateSshCertificateRequest {
    #[prost(string, tag = "5")]
    pub public_key: ::prost::alloc::string::String,
    /// the same certificate is generated for both an organization and a cloud in that organization
    #[prost(oneof = "generate_ssh_certificate_request::Scope", tags = "1, 2")]
    pub scope: ::core::option::Option<generate_ssh_certificate_request::Scope>,
    /// if empty, use default login for current subject
    #[prost(oneof = "generate_ssh_certificate_request::Subject", tags = "3, 4")]
    pub subject: ::core::option::Option<generate_ssh_certificate_request::Subject>,
}
/// Nested message and enum types in `GenerateSshCertificateRequest`.
pub mod generate_ssh_certificate_request {
    /// the same certificate is generated for both an organization and a cloud in that organization
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Scope {
        /// the cloud must be attached to an organization
        #[prost(string, tag = "1")]
        CloudId(::prost::alloc::string::String),
        #[prost(string, tag = "2")]
        OrganizationId(::prost::alloc::string::String),
    }
    /// if empty, use default login for current subject
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Subject {
        /// specify subject to generate certificate for default login
        #[prost(string, tag = "3")]
        SubjectId(::prost::alloc::string::String),
        /// specify os_login for a specific login
        #[prost(string, tag = "4")]
        OsLogin(::prost::alloc::string::String),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenerateSshCertificateResponse {
    /// as per specification <https://cvsweb.openbsd.org/src/usr.bin/ssh/PROTOCOL.certkeys?annotate=HEAD>
    #[prost(string, tag = "1")]
    pub signed_certificate: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod ssh_certificate_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct SshCertificateServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl SshCertificateServiceClient<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> SshCertificateServiceClient<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,
        ) -> SshCertificateServiceClient<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,
        {
            SshCertificateServiceClient::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
        }
        /// Members of an organization can generate certificates for themselves
        /// Signing certificates for other users requires a special permission
        pub async fn generate(
            &mut self,
            request: impl tonic::IntoRequest<super::GenerateSshCertificateRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenerateSshCertificateResponse>,
            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.organizationmanager.v1.SshCertificateService/Generate",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.SshCertificateService",
                        "Generate",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListMembersRequest {
    /// ID of the Organization resource to list members for.
    #[prost(string, tag = "1")]
    pub organization_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 \[ListMembersResponse.next_page_token\]
    /// that can be used to get the next page of results in subsequent list requests.
    /// Acceptable values are 0 to 1000, inclusive. Default value: 100.
    #[prost(int64, tag = "2")]
    pub page_size: i64,
    /// Page token. Set \[page_token\]
    /// to the \[ListMembersResponse.next_page_token\]
    /// returned by a previous list request to get the next page of results.
    #[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 ListMembersResponse {
    /// List of users for the specified organization.
    #[prost(message, repeated, tag = "1")]
    pub users: ::prost::alloc::vec::Vec<list_members_response::OrganizationUser>,
    /// This token allows you to get the next page of results for list requests. If the number of results
    /// is larger than \[ListMembersRequest.page_size\], use the \[next_page_token\] as the value
    /// for the \[ListMembersRequest.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,
}
/// Nested message and enum types in `ListMembersResponse`.
pub mod list_members_response {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct OrganizationUser {
        /// OpenID standard claims with additional Cloud Organization claims.
        #[prost(message, optional, tag = "1")]
        pub subject_claims: ::core::option::Option<
            super::super::super::oauth::SubjectClaims,
        >,
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteMembershipRequest {
    /// ID of the organization to delete membership.
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
    /// ID of the subject that is being deleted from organization.
    /// By default equals to authenticated subject.
    #[prost(string, tag = "2")]
    pub subject_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteMembershipMetadata {
    /// ID of the organization to delete membership.
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
    /// ID of the subject that is being deleted from organization.
    #[prost(string, tag = "2")]
    pub subject_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteMembershipResponse {
    /// ID of the organization to delete membership.
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
    /// ID of the subject that is being deleted from organization.
    #[prost(string, tag = "2")]
    pub subject_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod user_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// A set of methods for managing Organization users.
    #[derive(Debug, Clone)]
    pub struct UserServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl UserServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> UserServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> UserServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            UserServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// List organization active members.
        pub async fn list_members(
            &mut self,
            request: impl tonic::IntoRequest<super::ListMembersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListMembersResponse>,
            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.organizationmanager.v1.UserService/ListMembers",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.UserService",
                        "ListMembers",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Delete user membership.
        pub async fn delete_membership(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteMembershipRequest>,
        ) -> 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.organizationmanager.v1.UserService/DeleteMembership",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.UserService",
                        "DeleteMembership",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UserSshKey {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub subject_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub data: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub fingerprint: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub organization_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "7")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Used for temporary keys, if empty the key doesn't expire
    #[prost(message, optional, tag = "8")]
    pub expires_at: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetUserSshKeyRequest {
    #[prost(string, tag = "1")]
    pub user_ssh_key_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListUserSshKeysRequest {
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
    /// if empty, list all organization keys
    #[prost(string, tag = "2")]
    pub subject_id: ::prost::alloc::string::String,
    #[prost(int64, tag = "3")]
    pub page_size: i64,
    #[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 ListUserSshKeysResponse {
    #[prost(message, repeated, tag = "1")]
    pub ssh_keys: ::prost::alloc::vec::Vec<UserSshKey>,
    #[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 CreateUserSshKeyRequest {
    #[prost(string, tag = "1")]
    pub organization_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub subject_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub data: ::prost::alloc::string::String,
    #[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 CreateUserSshKeyMetadata {
    #[prost(string, tag = "1")]
    pub user_ssh_key_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub organization_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateUserSshKeyRequest {
    #[prost(string, tag = "1")]
    pub user_ssh_key_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    #[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 UpdateUserSshKeyMetadata {
    #[prost(string, tag = "1")]
    pub user_ssh_key_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteUserSshKeyRequest {
    #[prost(string, tag = "1")]
    pub user_ssh_key_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteUserSshKeyMetadata {
    #[prost(string, tag = "1")]
    pub user_ssh_key_id: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod user_ssh_key_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct UserSshKeyServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl UserSshKeyServiceClient<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> UserSshKeyServiceClient<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,
        ) -> UserSshKeyServiceClient<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,
        {
            UserSshKeyServiceClient::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
        }
        pub async fn get(
            &mut self,
            request: impl tonic::IntoRequest<super::GetUserSshKeyRequest>,
        ) -> std::result::Result<tonic::Response<super::UserSshKey>, 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.organizationmanager.v1.UserSshKeyService/Get",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.UserSshKeyService",
                        "Get",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn list(
            &mut self,
            request: impl tonic::IntoRequest<super::ListUserSshKeysRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListUserSshKeysResponse>,
            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.organizationmanager.v1.UserSshKeyService/List",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.UserSshKeyService",
                        "List",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn create(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateUserSshKeyRequest>,
        ) -> 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.organizationmanager.v1.UserSshKeyService/Create",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.UserSshKeyService",
                        "Create",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn update(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateUserSshKeyRequest>,
        ) -> 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.organizationmanager.v1.UserSshKeyService/Update",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.UserSshKeyService",
                        "Update",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn delete(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteUserSshKeyRequest>,
        ) -> 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.organizationmanager.v1.UserSshKeyService/Delete",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yandex.cloud.organizationmanager.v1.UserSshKeyService",
                        "Delete",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}