google-cloud-iam-v1 1.8.0

// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#![allow(rustdoc::redundant_explicit_links)]
#![allow(rustdoc::broken_intra_doc_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gaxi;
extern crate google_cloud_gax;
extern crate google_cloud_type;
extern crate serde;
extern crate serde_json;
extern crate serde_with;
extern crate std;
extern crate tracing;
extern crate wkt;

mod debug;
mod deserialize;
mod serialize;

/// Request message for `SetIamPolicy` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SetIamPolicyRequest {
    /// REQUIRED: The resource for which the policy is being specified.
    /// See the operation documentation for the appropriate value for this field.
    pub resource: std::string::String,

    /// REQUIRED: The complete policy to be applied to the `resource`. The size of
    /// the policy is limited to a few 10s of KB. An empty policy is a
    /// valid policy but certain Cloud Platform services (such as Projects)
    /// might reject them.
    pub policy: std::option::Option<crate::model::Policy>,

    /// OPTIONAL: A FieldMask specifying which fields of the policy to modify. Only
    /// the fields in the mask will be modified. If no mask is provided, the
    /// following default mask is used:
    ///
    /// `paths: "bindings, etag"`
    pub update_mask: std::option::Option<wkt::FieldMask>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SetIamPolicyRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [resource][crate::model::SetIamPolicyRequest::resource].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::SetIamPolicyRequest;
    /// let x = SetIamPolicyRequest::new().set_resource("example");
    /// ```
    pub fn set_resource<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.resource = v.into();
        self
    }

    /// Sets the value of [policy][crate::model::SetIamPolicyRequest::policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::SetIamPolicyRequest;
    /// use google_cloud_iam_v1::model::Policy;
    /// let x = SetIamPolicyRequest::new().set_policy(Policy::default()/* use setters */);
    /// ```
    pub fn set_policy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Policy>,
    {
        self.policy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [policy][crate::model::SetIamPolicyRequest::policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::SetIamPolicyRequest;
    /// use google_cloud_iam_v1::model::Policy;
    /// let x = SetIamPolicyRequest::new().set_or_clear_policy(Some(Policy::default()/* use setters */));
    /// let x = SetIamPolicyRequest::new().set_or_clear_policy(None::<Policy>);
    /// ```
    pub fn set_or_clear_policy<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Policy>,
    {
        self.policy = v.map(|x| x.into());
        self
    }

    /// Sets the value of [update_mask][crate::model::SetIamPolicyRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::SetIamPolicyRequest;
    /// use wkt::FieldMask;
    /// let x = SetIamPolicyRequest::new().set_update_mask(FieldMask::default()/* use setters */);
    /// ```
    pub fn set_update_mask<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::FieldMask>,
    {
        self.update_mask = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update_mask][crate::model::SetIamPolicyRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::SetIamPolicyRequest;
    /// use wkt::FieldMask;
    /// let x = SetIamPolicyRequest::new().set_or_clear_update_mask(Some(FieldMask::default()/* use setters */));
    /// let x = SetIamPolicyRequest::new().set_or_clear_update_mask(None::<FieldMask>);
    /// ```
    pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::FieldMask>,
    {
        self.update_mask = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for SetIamPolicyRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.iam.v1.SetIamPolicyRequest"
    }
}

/// Request message for `GetIamPolicy` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetIamPolicyRequest {
    /// REQUIRED: The resource for which the policy is being requested.
    /// See the operation documentation for the appropriate value for this field.
    pub resource: std::string::String,

    /// OPTIONAL: A `GetPolicyOptions` object for specifying options to
    /// `GetIamPolicy`.
    pub options: std::option::Option<crate::model::GetPolicyOptions>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetIamPolicyRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [resource][crate::model::GetIamPolicyRequest::resource].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::GetIamPolicyRequest;
    /// let x = GetIamPolicyRequest::new().set_resource("example");
    /// ```
    pub fn set_resource<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.resource = v.into();
        self
    }

    /// Sets the value of [options][crate::model::GetIamPolicyRequest::options].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::GetIamPolicyRequest;
    /// use google_cloud_iam_v1::model::GetPolicyOptions;
    /// let x = GetIamPolicyRequest::new().set_options(GetPolicyOptions::default()/* use setters */);
    /// ```
    pub fn set_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GetPolicyOptions>,
    {
        self.options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [options][crate::model::GetIamPolicyRequest::options].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::GetIamPolicyRequest;
    /// use google_cloud_iam_v1::model::GetPolicyOptions;
    /// let x = GetIamPolicyRequest::new().set_or_clear_options(Some(GetPolicyOptions::default()/* use setters */));
    /// let x = GetIamPolicyRequest::new().set_or_clear_options(None::<GetPolicyOptions>);
    /// ```
    pub fn set_or_clear_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::GetPolicyOptions>,
    {
        self.options = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for GetIamPolicyRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.iam.v1.GetIamPolicyRequest"
    }
}

/// Request message for `TestIamPermissions` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TestIamPermissionsRequest {
    /// REQUIRED: The resource for which the policy detail is being requested.
    /// See the operation documentation for the appropriate value for this field.
    pub resource: std::string::String,

    /// The set of permissions to check for the `resource`. Permissions with
    /// wildcards (such as '*' or 'storage.*') are not allowed. For more
    /// information see
    /// [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).
    pub permissions: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl TestIamPermissionsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [resource][crate::model::TestIamPermissionsRequest::resource].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::TestIamPermissionsRequest;
    /// let x = TestIamPermissionsRequest::new().set_resource("example");
    /// ```
    pub fn set_resource<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.resource = v.into();
        self
    }

    /// Sets the value of [permissions][crate::model::TestIamPermissionsRequest::permissions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::TestIamPermissionsRequest;
    /// let x = TestIamPermissionsRequest::new().set_permissions(["a", "b", "c"]);
    /// ```
    pub fn set_permissions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.permissions = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for TestIamPermissionsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.iam.v1.TestIamPermissionsRequest"
    }
}

/// Response message for `TestIamPermissions` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TestIamPermissionsResponse {
    /// A subset of `TestPermissionsRequest.permissions` that the caller is
    /// allowed.
    pub permissions: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl TestIamPermissionsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [permissions][crate::model::TestIamPermissionsResponse::permissions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::TestIamPermissionsResponse;
    /// let x = TestIamPermissionsResponse::new().set_permissions(["a", "b", "c"]);
    /// ```
    pub fn set_permissions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.permissions = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for TestIamPermissionsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.iam.v1.TestIamPermissionsResponse"
    }
}

/// Encapsulates settings provided to GetIamPolicy.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetPolicyOptions {
    /// Optional. The maximum policy version that will be used to format the
    /// policy.
    ///
    /// Valid values are 0, 1, and 3. Requests specifying an invalid value will be
    /// rejected.
    ///
    /// Requests for policies with any conditional role bindings must specify
    /// version 3. Policies with no conditional role bindings may specify any valid
    /// value or leave the field unset.
    ///
    /// The policy in the response might use the policy version that you specified,
    /// or it might use a lower policy version. For example, if you specify version
    /// 3, but the policy has no conditional role bindings, the response uses
    /// version 1.
    ///
    /// To learn which resources support conditions in their IAM policies, see the
    /// [IAM
    /// documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
    pub requested_policy_version: i32,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetPolicyOptions {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [requested_policy_version][crate::model::GetPolicyOptions::requested_policy_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::GetPolicyOptions;
    /// let x = GetPolicyOptions::new().set_requested_policy_version(42);
    /// ```
    pub fn set_requested_policy_version<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.requested_policy_version = v.into();
        self
    }
}

impl wkt::message::Message for GetPolicyOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.iam.v1.GetPolicyOptions"
    }
}

/// An Identity and Access Management (IAM) policy, which specifies access
/// controls for Google Cloud resources.
///
/// A `Policy` is a collection of `bindings`. A `binding` binds one or more
/// `members`, or principals, to a single `role`. Principals can be user
/// accounts, service accounts, Google groups, and domains (such as G Suite). A
/// `role` is a named list of permissions; each `role` can be an IAM predefined
/// role or a user-created custom role.
///
/// For some types of Google Cloud resources, a `binding` can also specify a
/// `condition`, which is a logical expression that allows access to a resource
/// only if the expression evaluates to `true`. A condition can add constraints
/// based on attributes of the request, the resource, or both. To learn which
/// resources support conditions in their IAM policies, see the
/// [IAM
/// documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
///
/// **JSON example:**
///
/// ```norust
///     {
///       "bindings": [
///         {
///           "role": "roles/resourcemanager.organizationAdmin",
///           "members": [
///             "user:mike@example.com",
///             "group:admins@example.com",
///             "domain:google.com",
///             "serviceAccount:my-project-id@appspot.gserviceaccount.com"
///           ]
///         },
///         {
///           "role": "roles/resourcemanager.organizationViewer",
///           "members": [
///             "user:eve@example.com"
///           ],
///           "condition": {
///             "title": "expirable access",
///             "description": "Does not grant access after Sep 2020",
///             "expression": "request.time <
///             timestamp('2020-10-01T00:00:00.000Z')",
///           }
///         }
///       ],
///       "etag": "BwWWja0YfJA=",
///       "version": 3
///     }
/// ```
///
/// **YAML example:**
///
/// ```norust
///     bindings:
///     - members:
///       - user:mike@example.com
///       - group:admins@example.com
///       - domain:google.com
///       - serviceAccount:my-project-id@appspot.gserviceaccount.com
///       role: roles/resourcemanager.organizationAdmin
///     - members:
///       - user:eve@example.com
///       role: roles/resourcemanager.organizationViewer
///       condition:
///         title: expirable access
///         description: Does not grant access after Sep 2020
///         expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
///     etag: BwWWja0YfJA=
///     version: 3
/// ```
///
/// For a description of IAM and its features, see the
/// [IAM documentation](https://cloud.google.com/iam/docs/).
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Policy {
    /// Specifies the format of the policy.
    ///
    /// Valid values are `0`, `1`, and `3`. Requests that specify an invalid value
    /// are rejected.
    ///
    /// Any operation that affects conditional role bindings must specify version
    /// `3`. This requirement applies to the following operations:
    ///
    /// * Getting a policy that includes a conditional role binding
    /// * Adding a conditional role binding to a policy
    /// * Changing a conditional role binding in a policy
    /// * Removing any role binding, with or without a condition, from a policy
    ///   that includes conditions
    ///
    /// **Important:** If you use IAM Conditions, you must include the `etag` field
    /// whenever you call `setIamPolicy`. If you omit this field, then IAM allows
    /// you to overwrite a version `3` policy with a version `1` policy, and all of
    /// the conditions in the version `3` policy are lost.
    ///
    /// If a policy does not include any conditions, operations on that policy may
    /// specify any valid version or leave the field unset.
    ///
    /// To learn which resources support conditions in their IAM policies, see the
    /// [IAM
    /// documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
    pub version: i32,

    /// Associates a list of `members`, or principals, with a `role`. Optionally,
    /// may specify a `condition` that determines how and when the `bindings` are
    /// applied. Each of the `bindings` must contain at least one principal.
    ///
    /// The `bindings` in a `Policy` can refer to up to 1,500 principals; up to 250
    /// of these principals can be Google groups. Each occurrence of a principal
    /// counts towards these limits. For example, if the `bindings` grant 50
    /// different roles to `user:alice@example.com`, and not to any other
    /// principal, then you can add another 1,450 principals to the `bindings` in
    /// the `Policy`.
    pub bindings: std::vec::Vec<crate::model::Binding>,

    /// Specifies cloud audit logging configuration for this policy.
    pub audit_configs: std::vec::Vec<crate::model::AuditConfig>,

    /// `etag` is used for optimistic concurrency control as a way to help
    /// prevent simultaneous updates of a policy from overwriting each other.
    /// It is strongly suggested that systems make use of the `etag` in the
    /// read-modify-write cycle to perform policy updates in order to avoid race
    /// conditions: An `etag` is returned in the response to `getIamPolicy`, and
    /// systems are expected to put that etag in the request to `setIamPolicy` to
    /// ensure that their change will be applied to the same version of the policy.
    ///
    /// **Important:** If you use IAM Conditions, you must include the `etag` field
    /// whenever you call `setIamPolicy`. If you omit this field, then IAM allows
    /// you to overwrite a version `3` policy with a version `1` policy, and all of
    /// the conditions in the version `3` policy are lost.
    pub etag: ::bytes::Bytes,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Policy {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [version][crate::model::Policy::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::Policy;
    /// let x = Policy::new().set_version(42);
    /// ```
    pub fn set_version<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.version = v.into();
        self
    }

    /// Sets the value of [bindings][crate::model::Policy::bindings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::Policy;
    /// use google_cloud_iam_v1::model::Binding;
    /// let x = Policy::new()
    ///     .set_bindings([
    ///         Binding::default()/* use setters */,
    ///         Binding::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_bindings<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Binding>,
    {
        use std::iter::Iterator;
        self.bindings = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [audit_configs][crate::model::Policy::audit_configs].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::Policy;
    /// use google_cloud_iam_v1::model::AuditConfig;
    /// let x = Policy::new()
    ///     .set_audit_configs([
    ///         AuditConfig::default()/* use setters */,
    ///         AuditConfig::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_audit_configs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AuditConfig>,
    {
        use std::iter::Iterator;
        self.audit_configs = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [etag][crate::model::Policy::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::Policy;
    /// let x = Policy::new().set_etag(bytes::Bytes::from_static(b"example"));
    /// ```
    pub fn set_etag<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.etag = v.into();
        self
    }
}

impl wkt::message::Message for Policy {
    fn typename() -> &'static str {
        "type.googleapis.com/google.iam.v1.Policy"
    }
}

/// Associates `members`, or principals, with a `role`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Binding {
    /// Role that is assigned to the list of `members`, or principals.
    /// For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
    pub role: std::string::String,

    /// Specifies the principals requesting access for a Google Cloud resource.
    /// `members` can have the following values:
    ///
    /// * `allUsers`: A special identifier that represents anyone who is
    ///   on the internet; with or without a Google account.
    ///
    /// * `allAuthenticatedUsers`: A special identifier that represents anyone
    ///   who is authenticated with a Google account or a service account.
    ///
    /// * `user:{emailid}`: An email address that represents a specific Google
    ///   account. For example, `alice@example.com` .
    ///
    /// * `serviceAccount:{emailid}`: An email address that represents a service
    ///   account. For example, `my-other-app@appspot.gserviceaccount.com`.
    ///
    /// * `group:{emailid}`: An email address that represents a Google group.
    ///   For example, `admins@example.com`.
    ///
    /// * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique
    ///   identifier) representing a user that has been recently deleted. For
    ///   example, `alice@example.com?uid=123456789012345678901`. If the user is
    ///   recovered, this value reverts to `user:{emailid}` and the recovered user
    ///   retains the role in the binding.
    ///
    /// * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus
    ///   unique identifier) representing a service account that has been recently
    ///   deleted. For example,
    ///   `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`.
    ///   If the service account is undeleted, this value reverts to
    ///   `serviceAccount:{emailid}` and the undeleted service account retains the
    ///   role in the binding.
    ///
    /// * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique
    ///   identifier) representing a Google group that has been recently
    ///   deleted. For example, `admins@example.com?uid=123456789012345678901`. If
    ///   the group is recovered, this value reverts to `group:{emailid}` and the
    ///   recovered group retains the role in the binding.
    ///
    /// * `domain:{domain}`: The G Suite domain (primary) that represents all the
    ///   users of that domain. For example, `google.com` or `example.com`.
    ///
    pub members: std::vec::Vec<std::string::String>,

    /// The condition that is associated with this binding.
    ///
    /// If the condition evaluates to `true`, then this binding applies to the
    /// current request.
    ///
    /// If the condition evaluates to `false`, then this binding does not apply to
    /// the current request. However, a different role binding might grant the same
    /// role to one or more of the principals in this binding.
    ///
    /// To learn which resources support conditions in their IAM policies, see the
    /// [IAM
    /// documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
    pub condition: std::option::Option<google_cloud_type::model::Expr>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Binding {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [role][crate::model::Binding::role].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::Binding;
    /// let x = Binding::new().set_role("example");
    /// ```
    pub fn set_role<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.role = v.into();
        self
    }

    /// Sets the value of [members][crate::model::Binding::members].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::Binding;
    /// let x = Binding::new().set_members(["a", "b", "c"]);
    /// ```
    pub fn set_members<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.members = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [condition][crate::model::Binding::condition].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::Binding;
    /// use google_cloud_type::model::Expr;
    /// let x = Binding::new().set_condition(Expr::default()/* use setters */);
    /// ```
    pub fn set_condition<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Expr>,
    {
        self.condition = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [condition][crate::model::Binding::condition].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::Binding;
    /// use google_cloud_type::model::Expr;
    /// let x = Binding::new().set_or_clear_condition(Some(Expr::default()/* use setters */));
    /// let x = Binding::new().set_or_clear_condition(None::<Expr>);
    /// ```
    pub fn set_or_clear_condition<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Expr>,
    {
        self.condition = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for Binding {
    fn typename() -> &'static str {
        "type.googleapis.com/google.iam.v1.Binding"
    }
}

/// Specifies the audit configuration for a service.
/// The configuration determines which permission types are logged, and what
/// identities, if any, are exempted from logging.
/// An AuditConfig must have one or more AuditLogConfigs.
///
/// If there are AuditConfigs for both `allServices` and a specific service,
/// the union of the two AuditConfigs is used for that service: the log_types
/// specified in each AuditConfig are enabled, and the exempted_members in each
/// AuditLogConfig are exempted.
///
/// Example Policy with multiple AuditConfigs:
///
/// ```norust
/// {
///   "audit_configs": [
///     {
///       "service": "allServices",
///       "audit_log_configs": [
///         {
///           "log_type": "DATA_READ",
///           "exempted_members": [
///             "user:jose@example.com"
///           ]
///         },
///         {
///           "log_type": "DATA_WRITE"
///         },
///         {
///           "log_type": "ADMIN_READ"
///         }
///       ]
///     },
///     {
///       "service": "sampleservice.googleapis.com",
///       "audit_log_configs": [
///         {
///           "log_type": "DATA_READ"
///         },
///         {
///           "log_type": "DATA_WRITE",
///           "exempted_members": [
///             "user:aliya@example.com"
///           ]
///         }
///       ]
///     }
///   ]
/// }
/// ```
///
/// For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ
/// logging. It also exempts `jose@example.com` from DATA_READ logging, and
/// `aliya@example.com` from DATA_WRITE logging.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AuditConfig {
    /// Specifies a service that will be enabled for audit logging.
    /// For example, `storage.googleapis.com`, `cloudsql.googleapis.com`.
    /// `allServices` is a special value that covers all services.
    pub service: std::string::String,

    /// The configuration for logging of each type of permission.
    pub audit_log_configs: std::vec::Vec<crate::model::AuditLogConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AuditConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [service][crate::model::AuditConfig::service].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::AuditConfig;
    /// let x = AuditConfig::new().set_service("example");
    /// ```
    pub fn set_service<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.service = v.into();
        self
    }

    /// Sets the value of [audit_log_configs][crate::model::AuditConfig::audit_log_configs].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::AuditConfig;
    /// use google_cloud_iam_v1::model::AuditLogConfig;
    /// let x = AuditConfig::new()
    ///     .set_audit_log_configs([
    ///         AuditLogConfig::default()/* use setters */,
    ///         AuditLogConfig::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_audit_log_configs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AuditLogConfig>,
    {
        use std::iter::Iterator;
        self.audit_log_configs = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for AuditConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.iam.v1.AuditConfig"
    }
}

/// Provides the configuration for logging a type of permissions.
/// Example:
///
/// ```norust
/// {
///   "audit_log_configs": [
///     {
///       "log_type": "DATA_READ",
///       "exempted_members": [
///         "user:jose@example.com"
///       ]
///     },
///     {
///       "log_type": "DATA_WRITE"
///     }
///   ]
/// }
/// ```
///
/// This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting
/// jose@example.com from DATA_READ logging.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AuditLogConfig {
    /// The log type that this config enables.
    pub log_type: crate::model::audit_log_config::LogType,

    /// Specifies the identities that do not cause logging for this type of
    /// permission.
    /// Follows the same format of
    /// [Binding.members][google.iam.v1.Binding.members].
    ///
    /// [google.iam.v1.Binding.members]: crate::model::Binding::members
    pub exempted_members: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AuditLogConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [log_type][crate::model::AuditLogConfig::log_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::AuditLogConfig;
    /// use google_cloud_iam_v1::model::audit_log_config::LogType;
    /// let x0 = AuditLogConfig::new().set_log_type(LogType::AdminRead);
    /// let x1 = AuditLogConfig::new().set_log_type(LogType::DataWrite);
    /// let x2 = AuditLogConfig::new().set_log_type(LogType::DataRead);
    /// ```
    pub fn set_log_type<T: std::convert::Into<crate::model::audit_log_config::LogType>>(
        mut self,
        v: T,
    ) -> Self {
        self.log_type = v.into();
        self
    }

    /// Sets the value of [exempted_members][crate::model::AuditLogConfig::exempted_members].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::AuditLogConfig;
    /// let x = AuditLogConfig::new().set_exempted_members(["a", "b", "c"]);
    /// ```
    pub fn set_exempted_members<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.exempted_members = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for AuditLogConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.iam.v1.AuditLogConfig"
    }
}

/// Defines additional types related to [AuditLogConfig].
pub mod audit_log_config {
    #[allow(unused_imports)]
    use super::*;

    /// The list of valid permission types for which logging can be configured.
    /// Admin writes are always logged, and are not configurable.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum LogType {
        /// Default case. Should never be this.
        Unspecified,
        /// Admin reads. Example: CloudIAM getIamPolicy
        AdminRead,
        /// Data writes. Example: CloudSQL Users create
        DataWrite,
        /// Data reads. Example: CloudSQL Users list
        DataRead,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [LogType::value] or
        /// [LogType::name].
        UnknownValue(log_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod log_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl LogType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::AdminRead => std::option::Option::Some(1),
                Self::DataWrite => std::option::Option::Some(2),
                Self::DataRead => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("LOG_TYPE_UNSPECIFIED"),
                Self::AdminRead => std::option::Option::Some("ADMIN_READ"),
                Self::DataWrite => std::option::Option::Some("DATA_WRITE"),
                Self::DataRead => std::option::Option::Some("DATA_READ"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for LogType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for LogType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for LogType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::AdminRead,
                2 => Self::DataWrite,
                3 => Self::DataRead,
                _ => Self::UnknownValue(log_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for LogType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "LOG_TYPE_UNSPECIFIED" => Self::Unspecified,
                "ADMIN_READ" => Self::AdminRead,
                "DATA_WRITE" => Self::DataWrite,
                "DATA_READ" => Self::DataRead,
                _ => Self::UnknownValue(log_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for LogType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::AdminRead => serializer.serialize_i32(1),
                Self::DataWrite => serializer.serialize_i32(2),
                Self::DataRead => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for LogType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<LogType>::new(
                ".google.iam.v1.AuditLogConfig.LogType",
            ))
        }
    }
}

/// The difference delta between two policies.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PolicyDelta {
    /// The delta for Bindings between two policies.
    pub binding_deltas: std::vec::Vec<crate::model::BindingDelta>,

    /// The delta for AuditConfigs between two policies.
    pub audit_config_deltas: std::vec::Vec<crate::model::AuditConfigDelta>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl PolicyDelta {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [binding_deltas][crate::model::PolicyDelta::binding_deltas].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::PolicyDelta;
    /// use google_cloud_iam_v1::model::BindingDelta;
    /// let x = PolicyDelta::new()
    ///     .set_binding_deltas([
    ///         BindingDelta::default()/* use setters */,
    ///         BindingDelta::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_binding_deltas<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::BindingDelta>,
    {
        use std::iter::Iterator;
        self.binding_deltas = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [audit_config_deltas][crate::model::PolicyDelta::audit_config_deltas].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::PolicyDelta;
    /// use google_cloud_iam_v1::model::AuditConfigDelta;
    /// let x = PolicyDelta::new()
    ///     .set_audit_config_deltas([
    ///         AuditConfigDelta::default()/* use setters */,
    ///         AuditConfigDelta::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_audit_config_deltas<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AuditConfigDelta>,
    {
        use std::iter::Iterator;
        self.audit_config_deltas = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for PolicyDelta {
    fn typename() -> &'static str {
        "type.googleapis.com/google.iam.v1.PolicyDelta"
    }
}

/// One delta entry for Binding. Each individual change (only one member in each
/// entry) to a binding will be a separate entry.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BindingDelta {
    /// The action that was performed on a Binding.
    /// Required
    pub action: crate::model::binding_delta::Action,

    /// Role that is assigned to `members`.
    /// For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
    /// Required
    pub role: std::string::String,

    /// A single identity requesting access for a Google Cloud resource.
    /// Follows the same format of Binding.members.
    /// Required
    pub member: std::string::String,

    /// The condition that is associated with this binding.
    pub condition: std::option::Option<google_cloud_type::model::Expr>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BindingDelta {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [action][crate::model::BindingDelta::action].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::BindingDelta;
    /// use google_cloud_iam_v1::model::binding_delta::Action;
    /// let x0 = BindingDelta::new().set_action(Action::Add);
    /// let x1 = BindingDelta::new().set_action(Action::Remove);
    /// ```
    pub fn set_action<T: std::convert::Into<crate::model::binding_delta::Action>>(
        mut self,
        v: T,
    ) -> Self {
        self.action = v.into();
        self
    }

    /// Sets the value of [role][crate::model::BindingDelta::role].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::BindingDelta;
    /// let x = BindingDelta::new().set_role("example");
    /// ```
    pub fn set_role<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.role = v.into();
        self
    }

    /// Sets the value of [member][crate::model::BindingDelta::member].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::BindingDelta;
    /// let x = BindingDelta::new().set_member("example");
    /// ```
    pub fn set_member<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.member = v.into();
        self
    }

    /// Sets the value of [condition][crate::model::BindingDelta::condition].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::BindingDelta;
    /// use google_cloud_type::model::Expr;
    /// let x = BindingDelta::new().set_condition(Expr::default()/* use setters */);
    /// ```
    pub fn set_condition<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Expr>,
    {
        self.condition = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [condition][crate::model::BindingDelta::condition].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::BindingDelta;
    /// use google_cloud_type::model::Expr;
    /// let x = BindingDelta::new().set_or_clear_condition(Some(Expr::default()/* use setters */));
    /// let x = BindingDelta::new().set_or_clear_condition(None::<Expr>);
    /// ```
    pub fn set_or_clear_condition<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Expr>,
    {
        self.condition = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for BindingDelta {
    fn typename() -> &'static str {
        "type.googleapis.com/google.iam.v1.BindingDelta"
    }
}

/// Defines additional types related to [BindingDelta].
pub mod binding_delta {
    #[allow(unused_imports)]
    use super::*;

    /// The type of action performed on a Binding in a policy.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Action {
        /// Unspecified.
        Unspecified,
        /// Addition of a Binding.
        Add,
        /// Removal of a Binding.
        Remove,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Action::value] or
        /// [Action::name].
        UnknownValue(action::UnknownValue),
    }

    #[doc(hidden)]
    pub mod action {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Action {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Add => std::option::Option::Some(1),
                Self::Remove => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("ACTION_UNSPECIFIED"),
                Self::Add => std::option::Option::Some("ADD"),
                Self::Remove => std::option::Option::Some("REMOVE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Action {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Action {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Action {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Add,
                2 => Self::Remove,
                _ => Self::UnknownValue(action::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Action {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "ACTION_UNSPECIFIED" => Self::Unspecified,
                "ADD" => Self::Add,
                "REMOVE" => Self::Remove,
                _ => Self::UnknownValue(action::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Action {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Add => serializer.serialize_i32(1),
                Self::Remove => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Action {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Action>::new(
                ".google.iam.v1.BindingDelta.Action",
            ))
        }
    }
}

/// One delta entry for AuditConfig. Each individual change (only one
/// exempted_member in each entry) to a AuditConfig will be a separate entry.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AuditConfigDelta {
    /// The action that was performed on an audit configuration in a policy.
    /// Required
    pub action: crate::model::audit_config_delta::Action,

    /// Specifies a service that was configured for Cloud Audit Logging.
    /// For example, `storage.googleapis.com`, `cloudsql.googleapis.com`.
    /// `allServices` is a special value that covers all services.
    /// Required
    pub service: std::string::String,

    /// A single identity that is exempted from "data access" audit
    /// logging for the `service` specified above.
    /// Follows the same format of Binding.members.
    pub exempted_member: std::string::String,

    /// Specifies the log_type that was be enabled. ADMIN_ACTIVITY is always
    /// enabled, and cannot be configured.
    /// Required
    pub log_type: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AuditConfigDelta {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [action][crate::model::AuditConfigDelta::action].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::AuditConfigDelta;
    /// use google_cloud_iam_v1::model::audit_config_delta::Action;
    /// let x0 = AuditConfigDelta::new().set_action(Action::Add);
    /// let x1 = AuditConfigDelta::new().set_action(Action::Remove);
    /// ```
    pub fn set_action<T: std::convert::Into<crate::model::audit_config_delta::Action>>(
        mut self,
        v: T,
    ) -> Self {
        self.action = v.into();
        self
    }

    /// Sets the value of [service][crate::model::AuditConfigDelta::service].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::AuditConfigDelta;
    /// let x = AuditConfigDelta::new().set_service("example");
    /// ```
    pub fn set_service<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.service = v.into();
        self
    }

    /// Sets the value of [exempted_member][crate::model::AuditConfigDelta::exempted_member].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::AuditConfigDelta;
    /// let x = AuditConfigDelta::new().set_exempted_member("example");
    /// ```
    pub fn set_exempted_member<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.exempted_member = v.into();
        self
    }

    /// Sets the value of [log_type][crate::model::AuditConfigDelta::log_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::AuditConfigDelta;
    /// let x = AuditConfigDelta::new().set_log_type("example");
    /// ```
    pub fn set_log_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.log_type = v.into();
        self
    }
}

impl wkt::message::Message for AuditConfigDelta {
    fn typename() -> &'static str {
        "type.googleapis.com/google.iam.v1.AuditConfigDelta"
    }
}

/// Defines additional types related to [AuditConfigDelta].
pub mod audit_config_delta {
    #[allow(unused_imports)]
    use super::*;

    /// The type of action performed on an audit configuration in a policy.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Action {
        /// Unspecified.
        Unspecified,
        /// Addition of an audit configuration.
        Add,
        /// Removal of an audit configuration.
        Remove,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Action::value] or
        /// [Action::name].
        UnknownValue(action::UnknownValue),
    }

    #[doc(hidden)]
    pub mod action {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Action {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Add => std::option::Option::Some(1),
                Self::Remove => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("ACTION_UNSPECIFIED"),
                Self::Add => std::option::Option::Some("ADD"),
                Self::Remove => std::option::Option::Some("REMOVE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Action {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Action {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Action {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Add,
                2 => Self::Remove,
                _ => Self::UnknownValue(action::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Action {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "ACTION_UNSPECIFIED" => Self::Unspecified,
                "ADD" => Self::Add,
                "REMOVE" => Self::Remove,
                _ => Self::UnknownValue(action::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Action {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Add => serializer.serialize_i32(1),
                Self::Remove => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Action {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Action>::new(
                ".google.iam.v1.AuditConfigDelta.Action",
            ))
        }
    }
}

/// Output-only policy member strings of a Google Cloud resource's built-in
/// identity.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ResourcePolicyMember {
    /// IAM policy binding member referring to a Google Cloud resource by
    /// user-assigned name (<https://google.aip.dev/122>). If a resource is deleted
    /// and recreated with the same name, the binding will be applicable to the new
    /// resource.
    ///
    /// Example:
    /// `principal://parametermanager.googleapis.com/projects/12345/name/locations/us-central1-a/parameters/my-parameter`
    pub iam_policy_name_principal: std::string::String,

    /// IAM policy binding member referring to a Google Cloud resource by
    /// system-assigned unique identifier (<https://google.aip.dev/148#uid>). If a
    /// resource is deleted and recreated with the same name, the binding will not
    /// be applicable to the new resource
    ///
    /// Example:
    /// `principal://parametermanager.googleapis.com/projects/12345/uid/locations/us-central1-a/parameters/a918fed5`
    pub iam_policy_uid_principal: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ResourcePolicyMember {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [iam_policy_name_principal][crate::model::ResourcePolicyMember::iam_policy_name_principal].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::ResourcePolicyMember;
    /// let x = ResourcePolicyMember::new().set_iam_policy_name_principal("example");
    /// ```
    pub fn set_iam_policy_name_principal<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.iam_policy_name_principal = v.into();
        self
    }

    /// Sets the value of [iam_policy_uid_principal][crate::model::ResourcePolicyMember::iam_policy_uid_principal].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_iam_v1::model::ResourcePolicyMember;
    /// let x = ResourcePolicyMember::new().set_iam_policy_uid_principal("example");
    /// ```
    pub fn set_iam_policy_uid_principal<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.iam_policy_uid_principal = v.into();
        self
    }
}

impl wkt::message::Message for ResourcePolicyMember {
    fn typename() -> &'static str {
        "type.googleapis.com/google.iam.v1.ResourcePolicyMember"
    }
}