googleapis_tonic_google_iam_v3beta/vec_u8_hash_map/

google.iam.v3beta.rs

// This file is @generated by prost-build.
/// Represents the metadata of the long-running operation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OperationMetadata {
    /// Output only. The time the operation was created.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the operation finished running.
    #[prost(message, optional, tag = "2")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Server-defined resource path for the target of the
    #[prost(string, tag = "3")]
    pub target: ::prost::alloc::string::String,
    /// Output only. Name of the verb executed by the operation.
    #[prost(string, tag = "4")]
    pub verb: ::prost::alloc::string::String,
    /// Output only. Human-readable status of the operation, if any.
    #[prost(string, tag = "5")]
    pub status_message: ::prost::alloc::string::String,
    /// Output only. Identifies whether the user has requested cancellation
    /// of the operation. Operations that have successfully been cancelled
    /// have [Operation.error][] value with a
    /// [google.rpc.Status.code][google.rpc.Status.code] of 1, corresponding to
    /// `Code.CANCELLED`.
    #[prost(bool, tag = "6")]
    pub requested_cancellation: bool,
    /// Output only. API version used to start the operation.
    #[prost(string, tag = "7")]
    pub api_version: ::prost::alloc::string::String,
}
/// IAM policy binding
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PolicyBinding {
    /// Identifier. The name of the policy binding, in the format
    /// `{binding_parent/locations/{location}/policyBindings/{policy_binding_id}`.
    /// The binding parent is the closest Resource Manager resource (i.e., Project,
    /// Folder or Organization) to the binding target.
    ///
    /// Format:
    ///
    /// * `projects/{project_id}/locations/{location}/policyBindings/{policy_binding_id}`
    /// * `projects/{project_number}/locations/{location}/policyBindings/{policy_binding_id}`
    /// * `folders/{folder_id}/locations/{location}/policyBindings/{policy_binding_id}`
    /// * `organizations/{organization_id}/locations/{location}/policyBindings/{policy_binding_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The globally unique ID of the policy binding. Assigned when
    /// the policy binding is created.
    #[prost(string, tag = "2")]
    pub uid: ::prost::alloc::string::String,
    /// Optional. The etag for the policy binding.
    /// If this is provided on update, it must match the server's etag.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
    /// Optional. The description of the policy binding. Must be less than or equal
    /// to 63 characters.
    #[prost(string, tag = "4")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. User defined annotations. See
    /// <https://google.aip.dev/148#annotations> for more details such as format and
    /// size limitations
    #[prost(map = "string, string", tag = "5")]
    pub annotations: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Required. Immutable. Target is the full resource name of the resource to
    /// which the policy will be bound. Immutable once set.
    #[prost(message, optional, tag = "6")]
    pub target: ::core::option::Option<policy_binding::Target>,
    /// Immutable. The kind of the policy to attach in this binding. This field
    /// must be one of the following:
    ///
    /// - Left empty (will be automatically set to the policy kind)
    /// - The input policy kind
    #[prost(enumeration = "policy_binding::PolicyKind", tag = "11")]
    pub policy_kind: i32,
    /// Required. Immutable. The resource name of the policy to be bound. The
    /// binding parent and policy must belong to the same Organization (or
    /// Project).
    #[prost(string, tag = "7")]
    pub policy: ::prost::alloc::string::String,
    /// Output only. The globally unique ID of the policy to be bound.
    #[prost(string, tag = "12")]
    pub policy_uid: ::prost::alloc::string::String,
    /// Optional. Condition can either be a principal condition or a resource
    /// condition. It depends on the type of target, the policy it is attached to,
    /// and/or the expression itself. When set, the `expression` field in the
    /// `Expr` must include from 1 to 10 subexpressions, joined by the "||"(Logical
    /// OR),
    /// "&&"(Logical AND) or "!"(Logical NOT) operators and cannot contain more
    /// than 250 characters.
    /// Allowed operations for principal.subject:
    ///
    /// - `principal.subject == <principal subject string>`
    /// - `principal.subject != <principal subject string>`
    /// - `principal.subject in \[<list of principal subjects>\]`
    /// - `principal.subject.startsWith(<string>)`
    /// - `principal.subject.endsWith(<string>)`
    ///
    /// Allowed operations for principal.type:
    ///
    /// - `principal.type == <principal type string>`
    /// - `principal.type != <principal type string>`
    /// - `principal.type in \[<list of principal types>\]`
    ///
    /// Supported principal types are Workspace, Workforce Pool, Workload Pool and
    /// Service Account. Allowed string must be one of:
    ///
    /// - iam.googleapis.com/WorkspaceIdentity
    /// - iam.googleapis.com/WorkforcePoolIdentity
    /// - iam.googleapis.com/WorkloadPoolIdentity
    /// - iam.googleapis.com/ServiceAccount
    ///
    /// When the bound policy is a principal access boundary policy, the only
    /// supported attributes in any subexpression are `principal.type` and
    /// `principal.subject`. An example expression is: "principal.type ==
    /// 'iam.googleapis.com/ServiceAccount'" or "principal.subject ==
    /// 'bob@example.com'".
    #[prost(message, optional, tag = "8")]
    pub condition: ::core::option::Option<super::super::r#type::Expr>,
    /// Output only. The time when the policy binding was created.
    #[prost(message, optional, tag = "9")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time when the policy binding was most recently updated.
    #[prost(message, optional, tag = "10")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
}
/// Nested message and enum types in `PolicyBinding`.
pub mod policy_binding {
    /// Target is the full resource name of the resource to which the policy will
    /// be bound. Immutable once set.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Target {
        #[prost(oneof = "target::Target", tags = "1")]
        pub target: ::core::option::Option<target::Target>,
    }
    /// Nested message and enum types in `Target`.
    pub mod target {
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Target {
            /// Immutable. Full Resource Name used for principal access boundary policy
            /// bindings Examples:
            ///
            /// * Organization:
            /// `//cloudresourcemanager.googleapis.com/organizations/ORGANIZATION_ID`
            /// * Folder: `//cloudresourcemanager.googleapis.com/folders/FOLDER_ID`
            /// * Project:
            ///      * `//cloudresourcemanager.googleapis.com/projects/PROJECT_NUMBER`
            ///      * `//cloudresourcemanager.googleapis.com/projects/PROJECT_ID`
            /// * Workload Identity Pool:
            /// `//iam.googleapis.com/projects/PROJECT_NUMBER/locations/LOCATION/workloadIdentityPools/WORKLOAD_POOL_ID`
            /// * Workforce Identity:
            /// `//iam.googleapis.com/locations/global/workforcePools/WORKFORCE_POOL_ID`
            /// * Workspace Identity:
            /// `//iam.googleapis.com/locations/global/workspace/WORKSPACE_ID`
            #[prost(string, tag = "1")]
            PrincipalSet(::prost::alloc::string::String),
        }
    }
    /// Different policy kinds supported in this binding.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum PolicyKind {
        /// Unspecified policy kind; Not a valid state
        Unspecified = 0,
        /// Principal access boundary policy kind
        PrincipalAccessBoundary = 1,
    }
    impl PolicyKind {
        /// 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 {
                Self::Unspecified => "POLICY_KIND_UNSPECIFIED",
                Self::PrincipalAccessBoundary => "PRINCIPAL_ACCESS_BOUNDARY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "POLICY_KIND_UNSPECIFIED" => Some(Self::Unspecified),
                "PRINCIPAL_ACCESS_BOUNDARY" => Some(Self::PrincipalAccessBoundary),
                _ => None,
            }
        }
    }
}
/// Request message for CreatePolicyBinding method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreatePolicyBindingRequest {
    /// Required. The parent resource where this policy binding will be created.
    /// The binding parent is the closest Resource Manager resource (Project,
    /// Folder or Organization) to the binding target.
    ///
    /// Format:
    ///
    /// * `projects/{project_id}/locations/{location}`
    /// * `projects/{project_number}/locations/{location}`
    /// * `folders/{folder_id}/locations/{location}`
    /// * `organizations/{organization_id}/locations/{location}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The ID to use for the policy binding, which will become the final
    /// component of the policy binding's resource name.
    ///
    /// This value must start with a lowercase letter followed by up to 62
    /// lowercase letters, numbers, hyphens, or dots. Pattern,
    /// /[a-z][a-z0-9-\.]{2,62}/.
    #[prost(string, tag = "2")]
    pub policy_binding_id: ::prost::alloc::string::String,
    /// Required. The policy binding to create.
    #[prost(message, optional, tag = "3")]
    pub policy_binding: ::core::option::Option<PolicyBinding>,
    /// Optional. If set, validate the request and preview the creation, but do not
    /// actually post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// Request message for GetPolicyBinding method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetPolicyBindingRequest {
    /// Required. The name of the policy binding to retrieve.
    ///
    /// Format:
    ///
    /// * `projects/{project_id}/locations/{location}/policyBindings/{policy_binding_id}`
    /// * `projects/{project_number}/locations/{location}/policyBindings/{policy_binding_id}`
    /// * `folders/{folder_id}/locations/{location}/policyBindings/{policy_binding_id}`
    /// * `organizations/{organization_id}/locations/{location}/policyBindings/{policy_binding_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for UpdatePolicyBinding method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdatePolicyBindingRequest {
    /// Required. The policy binding to update.
    ///
    /// The policy binding's `name` field is used to identify the policy binding to
    /// update.
    #[prost(message, optional, tag = "1")]
    pub policy_binding: ::core::option::Option<PolicyBinding>,
    /// Optional. If set, validate the request and preview the update, but do not
    /// actually post it.
    #[prost(bool, tag = "2")]
    pub validate_only: bool,
    /// Optional. The list of fields to update
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for DeletePolicyBinding method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeletePolicyBindingRequest {
    /// Required. The name of the policy binding to delete.
    ///
    /// Format:
    ///
    /// * `projects/{project_id}/locations/{location}/policyBindings/{policy_binding_id}`
    /// * `projects/{project_number}/locations/{location}/policyBindings/{policy_binding_id}`
    /// * `folders/{folder_id}/locations/{location}/policyBindings/{policy_binding_id}`
    /// * `organizations/{organization_id}/locations/{location}/policyBindings/{policy_binding_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The etag of the policy binding.
    /// If this is provided, it must match the server's etag.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
    /// Optional. If set, validate the request and preview the deletion, but do not
    /// actually post it.
    #[prost(bool, tag = "3")]
    pub validate_only: bool,
}
/// Request message for ListPolicyBindings method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPolicyBindingsRequest {
    /// Required. The parent resource, which owns the collection of policy
    /// bindings.
    ///
    /// Format:
    ///
    /// * `projects/{project_id}/locations/{location}`
    /// * `projects/{project_number}/locations/{location}`
    /// * `folders/{folder_id}/locations/{location}`
    /// * `organizations/{organization_id}/locations/{location}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of policy bindings to return. The service may
    /// return fewer than this value.
    ///
    /// If unspecified, at most 50 policy bindings will be returned.
    /// The maximum value is 1000; values above 1000 will be coerced to 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A page token, received from a previous `ListPolicyBindings` call.
    /// Provide this to retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to `ListPolicyBindings` must
    /// match the call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. An expression for filtering the results of the request. Filter
    /// rules are case insensitive. Some eligible fields for filtering are:
    ///
    /// + `target`
    /// + `policy`
    ///
    /// Some examples of filter queries:
    ///
    /// | Query            | Description                                         |
    /// |------------------|-----------------------------------------------------|
    /// | `target:ex*`     | The binding target's name starts with "ex".         |
    /// | `target:example` | The binding target's name is `example`.             |
    /// | `policy:example` | The binding policy's name is `example`.             |
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
/// Response message for ListPolicyBindings method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPolicyBindingsResponse {
    /// The policy bindings from the specified parent.
    #[prost(message, repeated, tag = "1")]
    pub policy_bindings: ::prost::alloc::vec::Vec<PolicyBinding>,
    /// Optional. A token, which can be sent as `page_token` to retrieve the next
    /// page. If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for SearchTargetPolicyBindings method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchTargetPolicyBindingsRequest {
    /// Required. The target resource, which is bound to the policy in the binding.
    ///
    /// Format:
    ///
    /// * `//iam.googleapis.com/locations/global/workforcePools/POOL_ID`
    /// * `//iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID`
    /// * `//iam.googleapis.com/locations/global/workspace/WORKSPACE_ID`
    /// * `//cloudresourcemanager.googleapis.com/projects/{project_number}`
    /// * `//cloudresourcemanager.googleapis.com/folders/{folder_id}`
    /// * `//cloudresourcemanager.googleapis.com/organizations/{organization_id}`
    #[prost(string, tag = "1")]
    pub target: ::prost::alloc::string::String,
    /// Optional. The maximum number of policy bindings to return. The service may
    /// return fewer than this value.
    ///
    /// If unspecified, at most 50 policy bindings will be returned.
    /// The maximum value is 1000; values above 1000 will be coerced to 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A page token, received from a previous
    /// `SearchTargetPolicyBindingsRequest` call. Provide this to retrieve the
    /// subsequent page.
    ///
    /// When paginating, all other parameters provided to
    /// `SearchTargetPolicyBindingsRequest` must match the call that provided the
    /// page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Required. The parent resource where this search will be performed. This
    /// should be the nearest Resource Manager resource (project, folder, or
    /// organization) to the target.
    ///
    /// Format:
    ///
    /// * `projects/{project_id}/locations/{location}`
    /// * `projects/{project_number}/locations/{location}`
    /// * `folders/{folder_id}/locations/{location}`
    /// * `organizations/{organization_id}/locations/{location}`
    #[prost(string, tag = "5")]
    pub parent: ::prost::alloc::string::String,
}
/// Response message for SearchTargetPolicyBindings method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchTargetPolicyBindingsResponse {
    /// The policy bindings bound to the specified target.
    #[prost(message, repeated, tag = "1")]
    pub policy_bindings: ::prost::alloc::vec::Vec<PolicyBinding>,
    /// Optional. A token, which can be sent as `page_token` to retrieve the next
    /// page. If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod policy_bindings_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// An interface for managing Identity and Access Management (IAM) policy
    /// bindings.
    #[derive(Debug, Clone)]
    pub struct PolicyBindingsClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> PolicyBindingsClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::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,
        ) -> PolicyBindingsClient<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> + std::marker::Send + std::marker::Sync,
        {
            PolicyBindingsClient::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
        }
        /// Creates a policy binding and returns a long-running operation.
        /// Callers will need the IAM permissions on both the policy and target.
        /// Once the binding is created, the policy is applied to the target.
        pub async fn create_policy_binding(
            &mut self,
            request: impl tonic::IntoRequest<super::CreatePolicyBindingRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.iam.v3beta.PolicyBindings/CreatePolicyBinding",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.iam.v3beta.PolicyBindings",
                        "CreatePolicyBinding",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a policy binding.
        pub async fn get_policy_binding(
            &mut self,
            request: impl tonic::IntoRequest<super::GetPolicyBindingRequest>,
        ) -> std::result::Result<tonic::Response<super::PolicyBinding>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.iam.v3beta.PolicyBindings/GetPolicyBinding",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.iam.v3beta.PolicyBindings",
                        "GetPolicyBinding",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a policy binding and returns a long-running operation.
        /// Callers will need the IAM permissions on the policy and target in the
        /// binding to update, and the IAM permission to remove the existing policy
        /// from the binding. Target is immutable and cannot be updated. Once the
        /// binding is updated, the new policy is applied to the target.
        pub async fn update_policy_binding(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdatePolicyBindingRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.iam.v3beta.PolicyBindings/UpdatePolicyBinding",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.iam.v3beta.PolicyBindings",
                        "UpdatePolicyBinding",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a policy binding and returns a long-running operation.
        /// Callers will need the IAM permissions on both the policy and target.
        /// Once the binding is deleted, the policy no longer applies to the target.
        pub async fn delete_policy_binding(
            &mut self,
            request: impl tonic::IntoRequest<super::DeletePolicyBindingRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.iam.v3beta.PolicyBindings/DeletePolicyBinding",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.iam.v3beta.PolicyBindings",
                        "DeletePolicyBinding",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists policy bindings.
        pub async fn list_policy_bindings(
            &mut self,
            request: impl tonic::IntoRequest<super::ListPolicyBindingsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListPolicyBindingsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.iam.v3beta.PolicyBindings/ListPolicyBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.iam.v3beta.PolicyBindings",
                        "ListPolicyBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Search policy bindings by target. Returns all policy binding objects bound
        /// directly to target.
        pub async fn search_target_policy_bindings(
            &mut self,
            request: impl tonic::IntoRequest<super::SearchTargetPolicyBindingsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SearchTargetPolicyBindingsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.iam.v3beta.PolicyBindings/SearchTargetPolicyBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.iam.v3beta.PolicyBindings",
                        "SearchTargetPolicyBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// An IAM principal access boundary policy resource.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PrincipalAccessBoundaryPolicy {
    /// Identifier. The resource name of the principal access boundary policy.
    ///
    /// The following format is supported:
    /// `organizations/{organization_id}/locations/{location}/principalAccessBoundaryPolicies/{policy_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The globally unique ID of the principal access boundary
    /// policy.
    #[prost(string, tag = "2")]
    pub uid: ::prost::alloc::string::String,
    /// Optional. The etag for the principal access boundary.
    /// If this is provided on update, it must match the server's etag.
    #[prost(string, tag = "3")]
    pub etag: ::prost::alloc::string::String,
    /// Optional. The description of the principal access boundary policy. Must be
    /// less than or equal to 63 characters.
    #[prost(string, tag = "4")]
    pub display_name: ::prost::alloc::string::String,
    /// Optional. User defined annotations. See
    /// <https://google.aip.dev/148#annotations> for more details such as format and
    /// size limitations
    #[prost(map = "string, string", tag = "5")]
    pub annotations: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Output only. The time when the principal access boundary policy was
    /// created.
    #[prost(message, optional, tag = "6")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time when the principal access boundary policy was most
    /// recently updated.
    #[prost(message, optional, tag = "7")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional. The details for the principal access boundary policy.
    #[prost(message, optional, tag = "8")]
    pub details: ::core::option::Option<PrincipalAccessBoundaryPolicyDetails>,
}
/// Principal access boundary policy details
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PrincipalAccessBoundaryPolicyDetails {
    /// Required. A list of principal access boundary policy rules. The number of
    /// rules in a policy is limited to 500.
    #[prost(message, repeated, tag = "1")]
    pub rules: ::prost::alloc::vec::Vec<PrincipalAccessBoundaryPolicyRule>,
    /// Optional.
    /// The version number that indicates which Google Cloud
    /// services are included in the enforcement (e.g. "latest", "1", ...). If
    /// empty, the PAB policy version will be set to the current latest version,
    /// and this version won't get updated when new versions are released.
    #[prost(string, tag = "4")]
    pub enforcement_version: ::prost::alloc::string::String,
}
/// Principal access boundary policy rule that defines the resource boundary.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PrincipalAccessBoundaryPolicyRule {
    /// Optional. The description of the principal access boundary policy rule.
    /// Must be less than or equal to 256 characters.
    #[prost(string, tag = "1")]
    pub description: ::prost::alloc::string::String,
    /// Required. A list of Cloud Resource Manager resources. The resource and all
    /// the descendants are included. The number of resources in a policy is
    /// limited to 500 across all rules.
    ///
    /// The following resource types are supported:
    ///
    /// * Organizations, such as
    /// `//cloudresourcemanager.googleapis.com/organizations/123`.
    /// * Folders, such as `//cloudresourcemanager.googleapis.com/folders/123`.
    /// * Projects, such as `//cloudresourcemanager.googleapis.com/projects/123`
    ///    or `//cloudresourcemanager.googleapis.com/projects/my-project-id`.
    #[prost(string, repeated, tag = "2")]
    pub resources: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Required. The access relationship of principals to the resources in this
    /// rule.
    #[prost(enumeration = "principal_access_boundary_policy_rule::Effect", tag = "3")]
    pub effect: i32,
}
/// Nested message and enum types in `PrincipalAccessBoundaryPolicyRule`.
pub mod principal_access_boundary_policy_rule {
    /// An effect to describe the access relationship.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Effect {
        /// Effect unspecified.
        Unspecified = 0,
        /// Allows access to the resources in this rule.
        Allow = 1,
    }
    impl Effect {
        /// 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 {
                Self::Unspecified => "EFFECT_UNSPECIFIED",
                Self::Allow => "ALLOW",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "EFFECT_UNSPECIFIED" => Some(Self::Unspecified),
                "ALLOW" => Some(Self::Allow),
                _ => None,
            }
        }
    }
}
/// Request message for CreatePrincipalAccessBoundaryPolicyRequest method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreatePrincipalAccessBoundaryPolicyRequest {
    /// Required. The parent resource where this principal access boundary policy
    /// will be created. Only organization is supported now.
    ///
    /// Format:
    ///    `organizations/{organization_id}/locations/{location}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The ID to use for the principal access boundary policy, which
    /// will become the final component of the principal access boundary policy's
    /// resource name.
    ///
    /// This value must start with a lowercase letter followed by up to 62
    /// lowercase letters, numbers, hyphens, or dots. Pattern,
    /// /[a-z][a-z0-9-\.]{2,62}/.
    #[prost(string, tag = "2")]
    pub principal_access_boundary_policy_id: ::prost::alloc::string::String,
    /// Required. The principal access boundary policy to create.
    #[prost(message, optional, tag = "3")]
    pub principal_access_boundary_policy: ::core::option::Option<
        PrincipalAccessBoundaryPolicy,
    >,
    /// Optional. If set, validate the request and preview the creation, but do not
    /// actually post it.
    #[prost(bool, tag = "4")]
    pub validate_only: bool,
}
/// Request message for GetPrincipalAccessBoundaryPolicy method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetPrincipalAccessBoundaryPolicyRequest {
    /// Required. The name of the principal access boundary policy to retrieve.
    ///
    /// Format:
    ///    `organizations/{organization_id}/locations/{location}/principalAccessBoundaryPolicies/{principal_access_boundary_policy_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for UpdatePrincipalAccessBoundaryPolicy method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdatePrincipalAccessBoundaryPolicyRequest {
    /// Required. The principal access boundary policy to update.
    ///
    /// The principal access boundary policy's `name` field is used to identify the
    /// policy to update.
    #[prost(message, optional, tag = "1")]
    pub principal_access_boundary_policy: ::core::option::Option<
        PrincipalAccessBoundaryPolicy,
    >,
    /// Optional. If set, validate the request and preview the update, but do not
    /// actually post it.
    #[prost(bool, tag = "2")]
    pub validate_only: bool,
    /// Optional. The list of fields to update
    #[prost(message, optional, tag = "3")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for DeletePrincipalAccessBoundaryPolicy method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeletePrincipalAccessBoundaryPolicyRequest {
    /// Required. The name of the principal access boundary policy to delete.
    ///
    /// Format:
    ///    `organizations/{organization_id}/locations/{location}/principalAccessBoundaryPolicies/{principal_access_boundary_policy_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The etag of the principal access boundary policy.
    /// If this is provided, it must match the server's etag.
    #[prost(string, tag = "2")]
    pub etag: ::prost::alloc::string::String,
    /// Optional. If set, validate the request and preview the deletion, but do not
    /// actually post it.
    #[prost(bool, tag = "3")]
    pub validate_only: bool,
    /// Optional. If set to true, the request will force the deletion of the Policy
    /// even if the Policy references PolicyBindings.
    #[prost(bool, tag = "4")]
    pub force: bool,
}
/// Request message for ListPrincipalAccessBoundaryPolicies method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPrincipalAccessBoundaryPoliciesRequest {
    /// Required. The parent resource, which owns the collection of principal
    /// access boundary policies.
    ///
    /// Format:
    ///    `organizations/{organization_id}/locations/{location}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. The maximum number of principal access boundary policies to
    /// return. The service may return fewer than this value.
    ///
    /// If unspecified, at most 50 principal access boundary policies will be
    /// returned. The maximum value is 1000; values above 1000 will be coerced to
    /// 1000.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. A page token, received from a previous
    /// `ListPrincipalAccessBoundaryPolicies` call. Provide this to retrieve the
    /// subsequent page.
    ///
    /// When paginating, all other parameters provided to
    /// `ListPrincipalAccessBoundaryPolicies` must match the call that provided the
    /// page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListPrincipalAccessBoundaryPoliciesResponse {
    /// The principal access boundary policies from the specified parent.
    #[prost(message, repeated, tag = "1")]
    pub principal_access_boundary_policies: ::prost::alloc::vec::Vec<
        PrincipalAccessBoundaryPolicy,
    >,
    /// Optional. A token, which can be sent as `page_token` to retrieve the next
    /// page. If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Request message for SearchPrincipalAccessBoundaryPolicyBindings rpc.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchPrincipalAccessBoundaryPolicyBindingsRequest {
    /// Required. The name of the principal access boundary policy.
    /// Format:
    ///   `organizations/{organization_id}/locations/{location}/principalAccessBoundaryPolicies/{principal_access_boundary_policy_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The maximum number of policy bindings to return. The service may
    /// return fewer than this value.
    ///
    /// If unspecified, at most 50 policy bindings will be returned.
    /// The maximum value is 1000; values above 1000 will be coerced to 1000.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// Optional. A page token, received from a previous
    /// `SearchPrincipalAccessBoundaryPolicyBindingsRequest` call. Provide this to
    /// retrieve the subsequent page.
    ///
    /// When paginating, all other parameters provided to
    /// `SearchPrincipalAccessBoundaryPolicyBindingsRequest` must match the call
    /// that provided the page token.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for SearchPrincipalAccessBoundaryPolicyBindings rpc.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchPrincipalAccessBoundaryPolicyBindingsResponse {
    /// The policy bindings that reference the specified policy.
    #[prost(message, repeated, tag = "1")]
    pub policy_bindings: ::prost::alloc::vec::Vec<PolicyBinding>,
    /// Optional. A token, which can be sent as `page_token` to retrieve the next
    /// page. If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod principal_access_boundary_policies_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Manages Identity and Access Management (IAM) principal access boundary
    /// policies.
    #[derive(Debug, Clone)]
    pub struct PrincipalAccessBoundaryPoliciesClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> PrincipalAccessBoundaryPoliciesClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::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,
        ) -> PrincipalAccessBoundaryPoliciesClient<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> + std::marker::Send + std::marker::Sync,
        {
            PrincipalAccessBoundaryPoliciesClient::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
        }
        /// Creates a principal access boundary policy, and returns a long running
        /// operation.
        pub async fn create_principal_access_boundary_policy(
            &mut self,
            request: impl tonic::IntoRequest<
                super::CreatePrincipalAccessBoundaryPolicyRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.iam.v3beta.PrincipalAccessBoundaryPolicies/CreatePrincipalAccessBoundaryPolicy",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.iam.v3beta.PrincipalAccessBoundaryPolicies",
                        "CreatePrincipalAccessBoundaryPolicy",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets a principal access boundary policy.
        pub async fn get_principal_access_boundary_policy(
            &mut self,
            request: impl tonic::IntoRequest<
                super::GetPrincipalAccessBoundaryPolicyRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::PrincipalAccessBoundaryPolicy>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.iam.v3beta.PrincipalAccessBoundaryPolicies/GetPrincipalAccessBoundaryPolicy",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.iam.v3beta.PrincipalAccessBoundaryPolicies",
                        "GetPrincipalAccessBoundaryPolicy",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates a principal access boundary policy.
        pub async fn update_principal_access_boundary_policy(
            &mut self,
            request: impl tonic::IntoRequest<
                super::UpdatePrincipalAccessBoundaryPolicyRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.iam.v3beta.PrincipalAccessBoundaryPolicies/UpdatePrincipalAccessBoundaryPolicy",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.iam.v3beta.PrincipalAccessBoundaryPolicies",
                        "UpdatePrincipalAccessBoundaryPolicy",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a principal access boundary policy.
        pub async fn delete_principal_access_boundary_policy(
            &mut self,
            request: impl tonic::IntoRequest<
                super::DeletePrincipalAccessBoundaryPolicyRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.iam.v3beta.PrincipalAccessBoundaryPolicies/DeletePrincipalAccessBoundaryPolicy",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.iam.v3beta.PrincipalAccessBoundaryPolicies",
                        "DeletePrincipalAccessBoundaryPolicy",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Lists principal access boundary policies.
        pub async fn list_principal_access_boundary_policies(
            &mut self,
            request: impl tonic::IntoRequest<
                super::ListPrincipalAccessBoundaryPoliciesRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::ListPrincipalAccessBoundaryPoliciesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.iam.v3beta.PrincipalAccessBoundaryPolicies/ListPrincipalAccessBoundaryPolicies",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.iam.v3beta.PrincipalAccessBoundaryPolicies",
                        "ListPrincipalAccessBoundaryPolicies",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Returns all policy bindings that bind a specific policy if a user has
        /// searchPolicyBindings permission on that policy.
        pub async fn search_principal_access_boundary_policy_bindings(
            &mut self,
            request: impl tonic::IntoRequest<
                super::SearchPrincipalAccessBoundaryPolicyBindingsRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::SearchPrincipalAccessBoundaryPolicyBindingsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.iam.v3beta.PrincipalAccessBoundaryPolicies/SearchPrincipalAccessBoundaryPolicyBindings",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.iam.v3beta.PrincipalAccessBoundaryPolicies",
                        "SearchPrincipalAccessBoundaryPolicyBindings",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}