google-cloud-workloadidentity-v1 1.0.0

// Copyright 2026 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::bare_urls)]
#![allow(rustdoc::broken_intra_doc_links)]
#![allow(rustdoc::invalid_html_tags)]
#![allow(rustdoc::redundant_explicit_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gaxi;
extern crate google_cloud_gax;
extern crate google_cloud_location;
extern crate google_cloud_longrunning;
extern crate google_cloud_lro;
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;

/// Message describing ServiceAgent object
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ServiceAgent {
    /// Identifier. The name of the service agent resource
    pub name: std::string::String,

    /// Optional. Name of the container that the service agent is associated with.
    /// For example:
    ///
    /// * projects/1234
    /// * folders/1234
    /// * organizations/2344
    pub container: std::string::String,

    /// Optional. The service the agent belongs to.
    /// For example, bigquery.googleapis.com
    pub service_producer: std::string::String,

    /// Optional. The principal identifier for the service agent. This identifier
    /// is used in allow policies to grant access to the service agent.
    pub principal: std::string::String,

    /// Optional. The role that should be granted to service agent on consumer
    /// project, if any. For example, "roles/aiplatform.serviceAgent".
    pub role: std::string::String,

    /// Output only. Service agent state.
    pub state: crate::model::service_agent::State,

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

impl ServiceAgent {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::ServiceAgent::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workloadidentity_v1::model::ServiceAgent;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let service_producer_id = "service_producer_id";
    /// # let service_agent_id = "service_agent_id";
    /// let x = ServiceAgent::new().set_name(format!("projects/{project_id}/locations/{location_id}/serviceProducers/{service_producer_id}/serviceAgents/{service_agent_id}"));
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

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

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

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

    /// Sets the value of [role][crate::model::ServiceAgent::role].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workloadidentity_v1::model::ServiceAgent;
    /// let x = ServiceAgent::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 [state][crate::model::ServiceAgent::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workloadidentity_v1::model::ServiceAgent;
    /// use google_cloud_workloadidentity_v1::model::service_agent::State;
    /// let x0 = ServiceAgent::new().set_state(State::Active);
    /// let x1 = ServiceAgent::new().set_state(State::Failed);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::service_agent::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }
}

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

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

    /// Enum for service agent `state`.
    ///
    /// # 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 State {
        /// Default service agent `state`. This value is used if the
        /// state is omitted.
        Unspecified,
        /// Indicates that the service agent has been created and can be used.
        Active,
        /// Indicates that the service agent was not created.
        Failed,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [State::value] or
        /// [State::name].
        UnknownValue(state::UnknownValue),
    }

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

    impl State {
        /// 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::Active => std::option::Option::Some(1),
                Self::Failed => 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("STATE_UNSPECIFIED"),
                Self::Active => std::option::Option::Some("ACTIVE"),
                Self::Failed => std::option::Option::Some("FAILED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

    impl std::fmt::Display for State {
        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 State {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Active,
                2 => Self::Failed,
                _ => Self::UnknownValue(state::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for State {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "STATE_UNSPECIFIED" => Self::Unspecified,
                "ACTIVE" => Self::Active,
                "FAILED" => Self::Failed,
                _ => Self::UnknownValue(state::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for State {
        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::Active => serializer.serialize_i32(1),
                Self::Failed => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// Message for creating all ServiceAgents for a ServiceProducer in a project and
/// location.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GenerateServiceAgentsRequest {
    /// Required. The parent resource. The `location` for the parent resource must
    /// be `global`.
    ///
    /// Examples:
    ///
    /// - projects/1234/locations/global/serviceProducers/bigquery.googleapis.com
    /// - folders/2344/locations/global/serviceProducers/vertexai.googleapis.com
    /// - organizations/3344/locations/global/serviceProducers/iam.googleapis.com
    pub parent: std::string::String,

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

impl GenerateServiceAgentsRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Message for creating all ServiceAgents for a ServiceProducer in a project and
/// location.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GenerateServiceAgentsResponse {
    /// The list of service agents
    pub service_agents: std::vec::Vec<crate::model::ServiceAgent>,

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

impl GenerateServiceAgentsResponse {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Represents the metadata of the long-running operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OperationMetadata {
    /// Output only. The time the operation was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time the operation finished running.
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Server-defined resource path for the target of the operation.
    pub target: std::string::String,

    /// Output only. Name of the verb executed by the operation.
    pub verb: std::string::String,

    /// Output only. Human-readable status of the operation, if any.
    pub status_message: std::string::String,

    /// Output only. Identifies whether the user has requested cancellation
    /// of the operation. Operations that have been cancelled successfully
    /// have
    /// [google.longrunning.Operation.error][google.longrunning.Operation.error]
    /// value with a [google.rpc.Status.code][google.rpc.Status.code] of `1`,
    /// corresponding to `Code.CANCELLED`.
    ///
    /// [google.longrunning.Operation.error]: google_cloud_longrunning::model::Operation::result
    /// [google.rpc.Status.code]: google_cloud_rpc::model::Status::code
    pub requested_cancellation: bool,

    /// Output only. API version used to start the operation.
    pub api_version: std::string::String,

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

impl OperationMetadata {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

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

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

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

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

    /// Sets the value of [requested_cancellation][crate::model::OperationMetadata::requested_cancellation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_workloadidentity_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_requested_cancellation(true);
    /// ```
    pub fn set_requested_cancellation<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.requested_cancellation = v.into();
        self
    }

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

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