google_cloud_tasks_v2/

model.rs

// Copyright 2025 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_iam_v1;
extern crate google_cloud_location;
extern crate google_cloud_longrunning;
extern crate google_cloud_lro;
extern crate google_cloud_rpc;
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
/// [ListQueues][google.cloud.tasks.v2.CloudTasks.ListQueues].
///
/// [google.cloud.tasks.v2.CloudTasks.ListQueues]: crate::client::CloudTasks::list_queues
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListQueuesRequest {
    /// Required. The location name.
    /// For example: `projects/PROJECT_ID/locations/LOCATION_ID`
    pub parent: std::string::String,

    /// `filter` can be used to specify a subset of queues. Any
    /// [Queue][google.cloud.tasks.v2.Queue] field can be used as a filter and
    /// several operators as supported. For example: `<=, <, >=, >, !=, =, :`. The
    /// filter syntax is the same as described in [Stackdriver's Advanced Logs
    /// Filters](https://cloud.google.com/logging/docs/view/advanced_filters).
    ///
    /// Sample filter "state: PAUSED".
    ///
    /// Note that using filters might cause fewer queues than the
    /// requested page_size to be returned.
    ///
    /// [google.cloud.tasks.v2.Queue]: crate::model::Queue
    pub filter: std::string::String,

    /// Requested page size.
    ///
    /// The maximum page size is 9800. If unspecified, the page size will
    /// be the maximum. Fewer queues than requested might be returned,
    /// even if more queues exist; use the
    /// [next_page_token][google.cloud.tasks.v2.ListQueuesResponse.next_page_token]
    /// in the response to determine if more queues exist.
    ///
    /// [google.cloud.tasks.v2.ListQueuesResponse.next_page_token]: crate::model::ListQueuesResponse::next_page_token
    pub page_size: i32,

    /// A token identifying the page of results to return.
    ///
    /// To request the first page results, page_token must be empty. To
    /// request the next page of results, page_token must be the value of
    /// [next_page_token][google.cloud.tasks.v2.ListQueuesResponse.next_page_token]
    /// returned from the previous call to
    /// [ListQueues][google.cloud.tasks.v2.CloudTasks.ListQueues] method. It is an
    /// error to switch the value of the
    /// [filter][google.cloud.tasks.v2.ListQueuesRequest.filter] while iterating
    /// through pages.
    ///
    /// [google.cloud.tasks.v2.CloudTasks.ListQueues]: crate::client::CloudTasks::list_queues
    /// [google.cloud.tasks.v2.ListQueuesRequest.filter]: crate::model::ListQueuesRequest::filter
    /// [google.cloud.tasks.v2.ListQueuesResponse.next_page_token]: crate::model::ListQueuesResponse::next_page_token
    pub page_token: std::string::String,

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

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

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

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

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

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

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

/// Response message for
/// [ListQueues][google.cloud.tasks.v2.CloudTasks.ListQueues].
///
/// [google.cloud.tasks.v2.CloudTasks.ListQueues]: crate::client::CloudTasks::list_queues
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListQueuesResponse {
    /// The list of queues.
    pub queues: std::vec::Vec<crate::model::Queue>,

    /// A token to retrieve next page of results.
    ///
    /// To return the next page of results, call
    /// [ListQueues][google.cloud.tasks.v2.CloudTasks.ListQueues] with this value
    /// as the [page_token][google.cloud.tasks.v2.ListQueuesRequest.page_token].
    ///
    /// If the next_page_token is empty, there are no more results.
    ///
    /// The page token is valid for only 2 hours.
    ///
    /// [google.cloud.tasks.v2.CloudTasks.ListQueues]: crate::client::CloudTasks::list_queues
    /// [google.cloud.tasks.v2.ListQueuesRequest.page_token]: crate::model::ListQueuesRequest::page_token
    pub next_page_token: std::string::String,

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

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

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

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

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

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListQueuesResponse {
    type PageItem = crate::model::Queue;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.queues
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Request message for [GetQueue][google.cloud.tasks.v2.CloudTasks.GetQueue].
///
/// [google.cloud.tasks.v2.CloudTasks.GetQueue]: crate::client::CloudTasks::get_queue
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetQueueRequest {
    /// Required. The resource name of the queue. For example:
    /// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`
    pub name: std::string::String,

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

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

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

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

/// Request message for
/// [CreateQueue][google.cloud.tasks.v2.CloudTasks.CreateQueue].
///
/// [google.cloud.tasks.v2.CloudTasks.CreateQueue]: crate::client::CloudTasks::create_queue
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateQueueRequest {
    /// Required. The location name in which the queue will be created.
    /// For example: `projects/PROJECT_ID/locations/LOCATION_ID`
    ///
    /// The list of allowed locations can be obtained by calling Cloud
    /// Tasks' implementation of
    /// [ListLocations][google.cloud.location.Locations.ListLocations].
    pub parent: std::string::String,

    /// Required. The queue to create.
    ///
    /// [Queue's name][google.cloud.tasks.v2.Queue.name] cannot be the same as an
    /// existing queue.
    ///
    /// [google.cloud.tasks.v2.Queue.name]: crate::model::Queue::name
    pub queue: std::option::Option<crate::model::Queue>,

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

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

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

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

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

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

/// Request message for
/// [UpdateQueue][google.cloud.tasks.v2.CloudTasks.UpdateQueue].
///
/// [google.cloud.tasks.v2.CloudTasks.UpdateQueue]: crate::client::CloudTasks::update_queue
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateQueueRequest {
    /// Required. The queue to create or update.
    ///
    /// The queue's [name][google.cloud.tasks.v2.Queue.name] must be specified.
    ///
    /// Output only fields cannot be modified using UpdateQueue.
    /// Any value specified for an output only field will be ignored.
    /// The queue's [name][google.cloud.tasks.v2.Queue.name] cannot be changed.
    ///
    /// [google.cloud.tasks.v2.Queue.name]: crate::model::Queue::name
    pub queue: std::option::Option<crate::model::Queue>,

    /// A mask used to specify which fields of the queue are being updated.
    ///
    /// If empty, then all fields will be updated.
    pub update_mask: std::option::Option<wkt::FieldMask>,

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

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

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

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

    /// Sets the value of [update_mask][crate::model::UpdateQueueRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::UpdateQueueRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateQueueRequest::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::UpdateQueueRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::UpdateQueueRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateQueueRequest::new().set_or_clear_update_mask(Some(FieldMask::default()/* use setters */));
    /// let x = UpdateQueueRequest::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 UpdateQueueRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.tasks.v2.UpdateQueueRequest"
    }
}

/// Request message for
/// [DeleteQueue][google.cloud.tasks.v2.CloudTasks.DeleteQueue].
///
/// [google.cloud.tasks.v2.CloudTasks.DeleteQueue]: crate::client::CloudTasks::delete_queue
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteQueueRequest {
    /// Required. The queue name. For example:
    /// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`
    pub name: std::string::String,

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

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

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

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

/// Request message for
/// [PurgeQueue][google.cloud.tasks.v2.CloudTasks.PurgeQueue].
///
/// [google.cloud.tasks.v2.CloudTasks.PurgeQueue]: crate::client::CloudTasks::purge_queue
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PurgeQueueRequest {
    /// Required. The queue name. For example:
    /// `projects/PROJECT_ID/location/LOCATION_ID/queues/QUEUE_ID`
    pub name: std::string::String,

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

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

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

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

/// Request message for
/// [PauseQueue][google.cloud.tasks.v2.CloudTasks.PauseQueue].
///
/// [google.cloud.tasks.v2.CloudTasks.PauseQueue]: crate::client::CloudTasks::pause_queue
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PauseQueueRequest {
    /// Required. The queue name. For example:
    /// `projects/PROJECT_ID/location/LOCATION_ID/queues/QUEUE_ID`
    pub name: std::string::String,

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

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

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

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

/// Request message for
/// [ResumeQueue][google.cloud.tasks.v2.CloudTasks.ResumeQueue].
///
/// [google.cloud.tasks.v2.CloudTasks.ResumeQueue]: crate::client::CloudTasks::resume_queue
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ResumeQueueRequest {
    /// Required. The queue name. For example:
    /// `projects/PROJECT_ID/location/LOCATION_ID/queues/QUEUE_ID`
    pub name: std::string::String,

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

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

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

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

/// Request message for listing tasks using
/// [ListTasks][google.cloud.tasks.v2.CloudTasks.ListTasks].
///
/// [google.cloud.tasks.v2.CloudTasks.ListTasks]: crate::client::CloudTasks::list_tasks
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListTasksRequest {
    /// Required. The queue name. For example:
    /// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`
    pub parent: std::string::String,

    /// The response_view specifies which subset of the
    /// [Task][google.cloud.tasks.v2.Task] will be returned.
    ///
    /// By default response_view is [BASIC][google.cloud.tasks.v2.Task.View.BASIC];
    /// not all information is retrieved by default because some data, such as
    /// payloads, might be desirable to return only when needed because
    /// of its large size or because of the sensitivity of data that it
    /// contains.
    ///
    /// Authorization for [FULL][google.cloud.tasks.v2.Task.View.FULL] requires
    /// `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/)
    /// permission on the [Task][google.cloud.tasks.v2.Task] resource.
    ///
    /// [google.cloud.tasks.v2.Task]: crate::model::Task
    /// [google.cloud.tasks.v2.Task.View.BASIC]: crate::model::task::View::Basic
    /// [google.cloud.tasks.v2.Task.View.FULL]: crate::model::task::View::Full
    pub response_view: crate::model::task::View,

    /// Maximum page size.
    ///
    /// Fewer tasks than requested might be returned, even if more tasks exist; use
    /// [next_page_token][google.cloud.tasks.v2.ListTasksResponse.next_page_token]
    /// in the response to determine if more tasks exist.
    ///
    /// The maximum page size is 1000. If unspecified, the page size will be the
    /// maximum.
    ///
    /// [google.cloud.tasks.v2.ListTasksResponse.next_page_token]: crate::model::ListTasksResponse::next_page_token
    pub page_size: i32,

    /// A token identifying the page of results to return.
    ///
    /// To request the first page results, page_token must be empty. To
    /// request the next page of results, page_token must be the value of
    /// [next_page_token][google.cloud.tasks.v2.ListTasksResponse.next_page_token]
    /// returned from the previous call to
    /// [ListTasks][google.cloud.tasks.v2.CloudTasks.ListTasks] method.
    ///
    /// The page token is valid for only 2 hours.
    ///
    /// [google.cloud.tasks.v2.CloudTasks.ListTasks]: crate::client::CloudTasks::list_tasks
    /// [google.cloud.tasks.v2.ListTasksResponse.next_page_token]: crate::model::ListTasksResponse::next_page_token
    pub page_token: std::string::String,

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

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

    /// Sets the value of [parent][crate::model::ListTasksRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::ListTasksRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let queue_id = "queue_id";
    /// let x = ListTasksRequest::new().set_parent(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}"));
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [response_view][crate::model::ListTasksRequest::response_view].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::ListTasksRequest;
    /// use google_cloud_tasks_v2::model::task::View;
    /// let x0 = ListTasksRequest::new().set_response_view(View::Basic);
    /// let x1 = ListTasksRequest::new().set_response_view(View::Full);
    /// ```
    pub fn set_response_view<T: std::convert::Into<crate::model::task::View>>(
        mut self,
        v: T,
    ) -> Self {
        self.response_view = v.into();
        self
    }

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

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

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

/// Response message for listing tasks using
/// [ListTasks][google.cloud.tasks.v2.CloudTasks.ListTasks].
///
/// [google.cloud.tasks.v2.CloudTasks.ListTasks]: crate::client::CloudTasks::list_tasks
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListTasksResponse {
    /// The list of tasks.
    pub tasks: std::vec::Vec<crate::model::Task>,

    /// A token to retrieve next page of results.
    ///
    /// To return the next page of results, call
    /// [ListTasks][google.cloud.tasks.v2.CloudTasks.ListTasks] with this value as
    /// the [page_token][google.cloud.tasks.v2.ListTasksRequest.page_token].
    ///
    /// If the next_page_token is empty, there are no more results.
    ///
    /// [google.cloud.tasks.v2.CloudTasks.ListTasks]: crate::client::CloudTasks::list_tasks
    /// [google.cloud.tasks.v2.ListTasksRequest.page_token]: crate::model::ListTasksRequest::page_token
    pub next_page_token: std::string::String,

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

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

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

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

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

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListTasksResponse {
    type PageItem = crate::model::Task;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.tasks
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Request message for getting a task using
/// [GetTask][google.cloud.tasks.v2.CloudTasks.GetTask].
///
/// [google.cloud.tasks.v2.CloudTasks.GetTask]: crate::client::CloudTasks::get_task
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetTaskRequest {
    /// Required. The task name. For example:
    /// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`
    pub name: std::string::String,

    /// The response_view specifies which subset of the
    /// [Task][google.cloud.tasks.v2.Task] will be returned.
    ///
    /// By default response_view is [BASIC][google.cloud.tasks.v2.Task.View.BASIC];
    /// not all information is retrieved by default because some data, such as
    /// payloads, might be desirable to return only when needed because
    /// of its large size or because of the sensitivity of data that it
    /// contains.
    ///
    /// Authorization for [FULL][google.cloud.tasks.v2.Task.View.FULL] requires
    /// `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/)
    /// permission on the [Task][google.cloud.tasks.v2.Task] resource.
    ///
    /// [google.cloud.tasks.v2.Task]: crate::model::Task
    /// [google.cloud.tasks.v2.Task.View.BASIC]: crate::model::task::View::Basic
    /// [google.cloud.tasks.v2.Task.View.FULL]: crate::model::task::View::Full
    pub response_view: crate::model::task::View,

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

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

    /// Sets the value of [name][crate::model::GetTaskRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::GetTaskRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let queue_id = "queue_id";
    /// # let task_id = "task_id";
    /// let x = GetTaskRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}/tasks/{task_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 [response_view][crate::model::GetTaskRequest::response_view].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::GetTaskRequest;
    /// use google_cloud_tasks_v2::model::task::View;
    /// let x0 = GetTaskRequest::new().set_response_view(View::Basic);
    /// let x1 = GetTaskRequest::new().set_response_view(View::Full);
    /// ```
    pub fn set_response_view<T: std::convert::Into<crate::model::task::View>>(
        mut self,
        v: T,
    ) -> Self {
        self.response_view = v.into();
        self
    }
}

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

/// Request message for
/// [CreateTask][google.cloud.tasks.v2.CloudTasks.CreateTask].
///
/// [google.cloud.tasks.v2.CloudTasks.CreateTask]: crate::client::CloudTasks::create_task
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateTaskRequest {
    /// Required. The queue name. For example:
    /// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`
    ///
    /// The queue must already exist.
    pub parent: std::string::String,

    /// Required. The task to add.
    ///
    /// Task names have the following format:
    /// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`.
    /// The user can optionally specify a task
    /// [name][google.cloud.tasks.v2.Task.name]. If a name is not specified then
    /// the system will generate a random unique task id, which will be set in the
    /// task returned in the [response][google.cloud.tasks.v2.Task.name].
    ///
    /// If [schedule_time][google.cloud.tasks.v2.Task.schedule_time] is not set or
    /// is in the past then Cloud Tasks will set it to the current time.
    ///
    /// Task De-duplication:
    ///
    /// Explicitly specifying a task ID enables task de-duplication.  If
    /// a task's ID is identical to that of an existing task or a task
    /// that was deleted or executed recently then the call will fail
    /// with [ALREADY_EXISTS][google.rpc.Code.ALREADY_EXISTS].
    /// The IDs of deleted tasks are not immediately available for reuse.  It can
    /// take up to 24 hours (or 9 days if the task's queue was created using a
    /// queue.yaml or queue.xml) for the task ID to be released and made available
    /// again.
    ///
    /// Because there is an extra lookup cost to identify duplicate task
    /// names, these [CreateTask][google.cloud.tasks.v2.CloudTasks.CreateTask]
    /// calls have significantly increased latency. Using hashed strings for the
    /// task id or for the prefix of the task id is recommended. Choosing task ids
    /// that are sequential or have sequential prefixes, for example using a
    /// timestamp, causes an increase in latency and error rates in all
    /// task commands. The infrastructure relies on an approximately
    /// uniform distribution of task ids to store and serve tasks
    /// efficiently.
    ///
    /// [google.cloud.tasks.v2.CloudTasks.CreateTask]: crate::client::CloudTasks::create_task
    /// [google.cloud.tasks.v2.Task.name]: crate::model::Task::name
    /// [google.cloud.tasks.v2.Task.schedule_time]: crate::model::Task::schedule_time
    pub task: std::option::Option<crate::model::Task>,

    /// The response_view specifies which subset of the
    /// [Task][google.cloud.tasks.v2.Task] will be returned.
    ///
    /// By default response_view is [BASIC][google.cloud.tasks.v2.Task.View.BASIC];
    /// not all information is retrieved by default because some data, such as
    /// payloads, might be desirable to return only when needed because
    /// of its large size or because of the sensitivity of data that it
    /// contains.
    ///
    /// Authorization for [FULL][google.cloud.tasks.v2.Task.View.FULL] requires
    /// `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/)
    /// permission on the [Task][google.cloud.tasks.v2.Task] resource.
    ///
    /// [google.cloud.tasks.v2.Task]: crate::model::Task
    /// [google.cloud.tasks.v2.Task.View.BASIC]: crate::model::task::View::Basic
    /// [google.cloud.tasks.v2.Task.View.FULL]: crate::model::task::View::Full
    pub response_view: crate::model::task::View,

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

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

    /// Sets the value of [parent][crate::model::CreateTaskRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::CreateTaskRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let queue_id = "queue_id";
    /// let x = CreateTaskRequest::new().set_parent(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}"));
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

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

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

    /// Sets the value of [response_view][crate::model::CreateTaskRequest::response_view].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::CreateTaskRequest;
    /// use google_cloud_tasks_v2::model::task::View;
    /// let x0 = CreateTaskRequest::new().set_response_view(View::Basic);
    /// let x1 = CreateTaskRequest::new().set_response_view(View::Full);
    /// ```
    pub fn set_response_view<T: std::convert::Into<crate::model::task::View>>(
        mut self,
        v: T,
    ) -> Self {
        self.response_view = v.into();
        self
    }
}

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

/// Request message for [BatchCreateTasks].
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchCreateTasksRequest {
    /// Required. The queue name. For example:
    /// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`
    ///
    /// The queue must already exist.
    pub parent: std::string::String,

    /// Required. The list of requests to create tasks.
    /// The queue specified in parent field of each CreateTaskRequest will be
    /// the same. This validation happens on the client side as well as in the
    /// handler.
    /// BatchCreateTasksRequest.parent will also be the same value as the
    /// individual CreateTaskRequest.parent.
    /// The maximum number of requests is 100.
    pub requests: std::vec::Vec<crate::model::CreateTaskRequest>,

    /// Optional. This field will be used to identify the long running operation,
    /// avoiding duplication when user retries. If not provided, then a UUID will
    /// be generated at server side.
    pub request_id: std::string::String,

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

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

    /// Sets the value of [parent][crate::model::BatchCreateTasksRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::BatchCreateTasksRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let queue_id = "queue_id";
    /// let x = BatchCreateTasksRequest::new().set_parent(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}"));
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

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

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

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

/// Request message for deleting a task using
/// [DeleteTask][google.cloud.tasks.v2.CloudTasks.DeleteTask].
///
/// [google.cloud.tasks.v2.CloudTasks.DeleteTask]: crate::client::CloudTasks::delete_task
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteTaskRequest {
    /// Required. The task name. For example:
    /// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`
    pub name: std::string::String,

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

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

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

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

/// Request message for deleting a batch of tasks using
/// [BatchDeleteTasks][google.cloud.tasks.v2.CloudTasks.BatchDeleteTasks].
///
/// [google.cloud.tasks.v2.CloudTasks.BatchDeleteTasks]: crate::client::CloudTasks::batch_delete_tasks
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchDeleteTasksRequest {
    /// Required. The queue name. For example:
    /// Format: `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`
    pub parent: std::string::String,

    /// Required. The names of the tasks to delete.
    /// A maximum of 1000 tasks can be deleted in a batch.
    /// For example:
    /// Format:
    /// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`
    pub names: std::vec::Vec<std::string::String>,

    /// Optional. This field will be used to identify the long running operation,
    /// avoiding duplication when user retries. If not provided, then a UUID will
    /// be generated at server side.
    pub request_id: std::string::String,

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

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

    /// Sets the value of [parent][crate::model::BatchDeleteTasksRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::BatchDeleteTasksRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let queue_id = "queue_id";
    /// let x = BatchDeleteTasksRequest::new().set_parent(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}"));
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [names][crate::model::BatchDeleteTasksRequest::names].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::BatchDeleteTasksRequest;
    /// let x = BatchDeleteTasksRequest::new().set_names(["a", "b", "c"]);
    /// ```
    pub fn set_names<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.names = v.into_iter().map(|i| i.into()).collect();
        self
    }

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

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

/// Metadata for the long-running operation returned by
/// [BatchDeleteTasks][google.cloud.tasks.v2.CloudTasks.BatchDeleteTasks].
/// This message is used to hold metadata information about the
/// batch delete tasks operation; that is, it is put in
/// [google.longrunning.Operation.metadata][google.longrunning.Operation.metadata].
///
/// [google.cloud.tasks.v2.CloudTasks.BatchDeleteTasks]: crate::client::CloudTasks::batch_delete_tasks
/// [google.longrunning.Operation.metadata]: google_cloud_longrunning::model::Operation::metadata
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchDeleteTasksMetadata {
    /// Output only. The time when the batch delete started.
    pub start_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time when the batch delete finished.
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The state of the batch delete operation.
    pub state: crate::model::batch_delete_tasks_metadata::State,

    /// Output only. A map of failed requests, where the key is the index of the
    /// request in BatchDeleteTasksRequest.names and the value is the error status.
    pub failed_requests: std::collections::HashMap<i32, google_cloud_rpc::model::Status>,

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

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

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

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

    /// Sets the value of [end_time][crate::model::BatchDeleteTasksMetadata::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::BatchDeleteTasksMetadata;
    /// use wkt::Timestamp;
    /// let x = BatchDeleteTasksMetadata::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::BatchDeleteTasksMetadata::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::BatchDeleteTasksMetadata;
    /// use wkt::Timestamp;
    /// let x = BatchDeleteTasksMetadata::new().set_or_clear_end_time(Some(Timestamp::default()/* use setters */));
    /// let x = BatchDeleteTasksMetadata::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 [state][crate::model::BatchDeleteTasksMetadata::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::BatchDeleteTasksMetadata;
    /// use google_cloud_tasks_v2::model::batch_delete_tasks_metadata::State;
    /// let x0 = BatchDeleteTasksMetadata::new().set_state(State::Running);
    /// let x1 = BatchDeleteTasksMetadata::new().set_state(State::Succeeded);
    /// let x2 = BatchDeleteTasksMetadata::new().set_state(State::PartiallySucceeded);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::batch_delete_tasks_metadata::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [failed_requests][crate::model::BatchDeleteTasksMetadata::failed_requests].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::BatchDeleteTasksMetadata;
    /// use google_cloud_rpc::model::Status;
    /// let x = BatchDeleteTasksMetadata::new().set_failed_requests([
    ///     (0, Status::default()/* use setters */),
    ///     (1, Status::default()/* use (different) setters */),
    /// ]);
    /// ```
    pub fn set_failed_requests<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<i32>,
        V: std::convert::Into<google_cloud_rpc::model::Status>,
    {
        use std::iter::Iterator;
        self.failed_requests = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }
}

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

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

    /// The state of the batch delete operation.
    /// This enum is not frozen and new values may be added in the future.
    ///
    /// # 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 {
        /// The default value. This value is used if the state is omitted.
        Unspecified,
        /// The batch delete is running.
        Running,
        /// The batch delete has finished and all tasks were successfully deleted.
        Succeeded,
        /// The batch delete has finished with partial success.
        /// The tasks that failed to be deleted are reported in
        /// [failed_requests][google.cloud.tasks.v2.BatchDeleteTasksMetadata.failed_requests].
        /// When all requests in the batch fail,
        /// [google.longrunning.Operation.error][google.longrunning.Operation.error]
        /// will be set with `code` = `google.rpc.Code.ABORTED` and `message` = "None
        /// of the requests succeeded, refer to
        /// BatchDeleteTasksMetadata.failed_requests for individual error details".
        ///
        /// [google.cloud.tasks.v2.BatchDeleteTasksMetadata.failed_requests]: crate::model::BatchDeleteTasksMetadata::failed_requests
        /// [google.longrunning.Operation.error]: google_cloud_longrunning::model::Operation::result
        PartiallySucceeded,
        /// The batch delete has failed.
        /// This means the overall batch delete operation failed to complete.
        /// This can happen due to an internal error preventing the operation from
        /// finishing.
        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::Running => std::option::Option::Some(1),
                Self::Succeeded => std::option::Option::Some(2),
                Self::PartiallySucceeded => std::option::Option::Some(3),
                Self::Failed => std::option::Option::Some(4),
                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::Running => std::option::Option::Some("RUNNING"),
                Self::Succeeded => std::option::Option::Some("SUCCEEDED"),
                Self::PartiallySucceeded => std::option::Option::Some("PARTIALLY_SUCCEEDED"),
                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::Running,
                2 => Self::Succeeded,
                3 => Self::PartiallySucceeded,
                4 => 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,
                "RUNNING" => Self::Running,
                "SUCCEEDED" => Self::Succeeded,
                "PARTIALLY_SUCCEEDED" => Self::PartiallySucceeded,
                "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::Running => serializer.serialize_i32(1),
                Self::Succeeded => serializer.serialize_i32(2),
                Self::PartiallySucceeded => serializer.serialize_i32(3),
                Self::Failed => serializer.serialize_i32(4),
                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.tasks.v2.BatchDeleteTasksMetadata.State",
            ))
        }
    }
}

/// Request message for forcing a task to run now using
/// [RunTask][google.cloud.tasks.v2.CloudTasks.RunTask].
///
/// [google.cloud.tasks.v2.CloudTasks.RunTask]: crate::client::CloudTasks::run_task
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RunTaskRequest {
    /// Required. The task name. For example:
    /// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`
    pub name: std::string::String,

    /// The response_view specifies which subset of the
    /// [Task][google.cloud.tasks.v2.Task] will be returned.
    ///
    /// By default response_view is [BASIC][google.cloud.tasks.v2.Task.View.BASIC];
    /// not all information is retrieved by default because some data, such as
    /// payloads, might be desirable to return only when needed because
    /// of its large size or because of the sensitivity of data that it
    /// contains.
    ///
    /// Authorization for [FULL][google.cloud.tasks.v2.Task.View.FULL] requires
    /// `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/)
    /// permission on the [Task][google.cloud.tasks.v2.Task] resource.
    ///
    /// [google.cloud.tasks.v2.Task]: crate::model::Task
    /// [google.cloud.tasks.v2.Task.View.BASIC]: crate::model::task::View::Basic
    /// [google.cloud.tasks.v2.Task.View.FULL]: crate::model::task::View::Full
    pub response_view: crate::model::task::View,

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

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

    /// Sets the value of [name][crate::model::RunTaskRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::RunTaskRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let queue_id = "queue_id";
    /// # let task_id = "task_id";
    /// let x = RunTaskRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}/tasks/{task_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 [response_view][crate::model::RunTaskRequest::response_view].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::RunTaskRequest;
    /// use google_cloud_tasks_v2::model::task::View;
    /// let x0 = RunTaskRequest::new().set_response_view(View::Basic);
    /// let x1 = RunTaskRequest::new().set_response_view(View::Full);
    /// ```
    pub fn set_response_view<T: std::convert::Into<crate::model::task::View>>(
        mut self,
        v: T,
    ) -> Self {
        self.response_view = v.into();
        self
    }
}

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

/// Request message for
/// [UpdateCmekConfig][google.cloud.tasks.v2.CloudTasks.UpdateCmekConfig].
///
/// [google.cloud.tasks.v2.CloudTasks.UpdateCmekConfig]: crate::client::CloudTasks::update_cmek_config
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateCmekConfigRequest {
    /// Required. The config to update.  Its name attribute distinguishes it.
    pub cmek_config: std::option::Option<crate::model::CmekConfig>,

    /// List of fields to be updated in this request.
    pub update_mask: std::option::Option<wkt::FieldMask>,

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

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

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

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

    /// Sets the value of [update_mask][crate::model::UpdateCmekConfigRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::UpdateCmekConfigRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateCmekConfigRequest::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::UpdateCmekConfigRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::UpdateCmekConfigRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateCmekConfigRequest::new().set_or_clear_update_mask(Some(FieldMask::default()/* use setters */));
    /// let x = UpdateCmekConfigRequest::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 UpdateCmekConfigRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.tasks.v2.UpdateCmekConfigRequest"
    }
}

/// Request message for
/// [GetCmekConfig][google.cloud.tasks.v2.CloudTasks.GetCmekConfig].
///
/// [google.cloud.tasks.v2.CloudTasks.GetCmekConfig]: crate::client::CloudTasks::get_cmek_config
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetCmekConfigRequest {
    /// Required. The config. For example:
    /// `projects/PROJECT_ID/locations/LOCATION_ID/CmekConfig`
    pub name: std::string::String,

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

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

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

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

/// Response message for [BatchCreateTasks].
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchCreateTasksResponse {
    /// The tasks that were successfully created.
    pub tasks: std::vec::Vec<crate::model::Task>,

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

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

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

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

/// Metadata message for [BatchCreateTasks].
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchCreateTasksMetadata {
    /// The time when the batch create started.
    pub start_time: std::option::Option<wkt::Timestamp>,

    /// The time when the batch create finished.
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The state of the batch create operation.
    pub state: crate::model::batch_create_tasks_metadata::State,

    /// A map of failed requests, where the key is the index of the request in
    /// BatchCreateTasksRequest.requests and the value is the error status.
    pub failed_requests: std::collections::HashMap<i32, google_cloud_rpc::model::Status>,

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

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

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

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

    /// Sets the value of [end_time][crate::model::BatchCreateTasksMetadata::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::BatchCreateTasksMetadata;
    /// use wkt::Timestamp;
    /// let x = BatchCreateTasksMetadata::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::BatchCreateTasksMetadata::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::BatchCreateTasksMetadata;
    /// use wkt::Timestamp;
    /// let x = BatchCreateTasksMetadata::new().set_or_clear_end_time(Some(Timestamp::default()/* use setters */));
    /// let x = BatchCreateTasksMetadata::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 [state][crate::model::BatchCreateTasksMetadata::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::BatchCreateTasksMetadata;
    /// use google_cloud_tasks_v2::model::batch_create_tasks_metadata::State;
    /// let x0 = BatchCreateTasksMetadata::new().set_state(State::Running);
    /// let x1 = BatchCreateTasksMetadata::new().set_state(State::Succeeded);
    /// let x2 = BatchCreateTasksMetadata::new().set_state(State::PartiallySucceeded);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::batch_create_tasks_metadata::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [failed_requests][crate::model::BatchCreateTasksMetadata::failed_requests].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::BatchCreateTasksMetadata;
    /// use google_cloud_rpc::model::Status;
    /// let x = BatchCreateTasksMetadata::new().set_failed_requests([
    ///     (0, Status::default()/* use setters */),
    ///     (1, Status::default()/* use (different) setters */),
    /// ]);
    /// ```
    pub fn set_failed_requests<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<i32>,
        V: std::convert::Into<google_cloud_rpc::model::Status>,
    {
        use std::iter::Iterator;
        self.failed_requests = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }
}

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

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

    /// The state of the batch create operation.
    ///
    /// # 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 {
        /// The default value. This value is used if the state is omitted.
        Unspecified,
        /// The batch create is running.
        Running,
        /// The batch create has finished.
        /// All tasks in the request were successfully created.
        Succeeded,
        /// The batch create has finished with partial success.
        /// The tasks that failed to be created are reported in
        /// [failed_requests][google.cloud.tasks.v2.BatchCreateTasksMetadata.failed_requests].
        ///
        /// [google.cloud.tasks.v2.BatchCreateTasksMetadata.failed_requests]: crate::model::BatchCreateTasksMetadata::failed_requests
        PartiallySucceeded,
        /// The batch create has failed.
        /// This means the overall batch create operation failed to complete.
        /// This can happen due to an internal error preventing the operation from
        /// finishing.
        Failed,
        /// The batch create was cancelled.
        Cancelled,
        /// 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::Running => std::option::Option::Some(1),
                Self::Succeeded => std::option::Option::Some(2),
                Self::PartiallySucceeded => std::option::Option::Some(5),
                Self::Failed => std::option::Option::Some(3),
                Self::Cancelled => std::option::Option::Some(4),
                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::Running => std::option::Option::Some("RUNNING"),
                Self::Succeeded => std::option::Option::Some("SUCCEEDED"),
                Self::PartiallySucceeded => std::option::Option::Some("PARTIALLY_SUCCEEDED"),
                Self::Failed => std::option::Option::Some("FAILED"),
                Self::Cancelled => std::option::Option::Some("CANCELLED"),
                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::Running,
                2 => Self::Succeeded,
                3 => Self::Failed,
                4 => Self::Cancelled,
                5 => Self::PartiallySucceeded,
                _ => 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,
                "RUNNING" => Self::Running,
                "SUCCEEDED" => Self::Succeeded,
                "PARTIALLY_SUCCEEDED" => Self::PartiallySucceeded,
                "FAILED" => Self::Failed,
                "CANCELLED" => Self::Cancelled,
                _ => 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::Running => serializer.serialize_i32(1),
                Self::Succeeded => serializer.serialize_i32(2),
                Self::PartiallySucceeded => serializer.serialize_i32(5),
                Self::Failed => serializer.serialize_i32(3),
                Self::Cancelled => serializer.serialize_i32(4),
                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.tasks.v2.BatchCreateTasksMetadata.State",
            ))
        }
    }
}

/// Describes the customer-managed encryption key (CMEK) configuration associated
/// with a project and location.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CmekConfig {
    /// Output only. The config resource name which includes the project and
    /// location and must end in 'cmekConfig', in the format
    /// `projects/PROJECT_ID/locations/LOCATION_ID/cmekConfig`
    pub name: std::string::String,

    /// Resource name of the Cloud KMS key, of the form
    /// `projects/PROJECT_ID/locations/LOCATION_ID/keyRings/KEY_RING_ID/cryptoKeys/KEY_ID`,
    /// that will be used to encrypt the Queues & Tasks in the region. Setting
    /// this as blank will turn off CMEK encryption.
    pub kms_key: std::string::String,

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

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

    /// Sets the value of [name][crate::model::CmekConfig::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::CmekConfig;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// let x = CmekConfig::new().set_name(format!("projects/{project_id}/locations/{location_id}/cmekConfig"));
    /// ```
    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 [kms_key][crate::model::CmekConfig::kms_key].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::CmekConfig;
    /// let x = CmekConfig::new().set_kms_key("example");
    /// ```
    pub fn set_kms_key<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.kms_key = v.into();
        self
    }
}

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

/// A queue is a container of related tasks. Queues are configured to manage
/// how those tasks are dispatched. Configurable properties include rate limits,
/// retry options, queue types, and others.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Queue {
    /// Caller-specified and required in
    /// [CreateQueue][google.cloud.tasks.v2.CloudTasks.CreateQueue], after which it
    /// becomes output only.
    ///
    /// The queue name.
    ///
    /// The queue name must have the following format:
    /// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`
    ///
    /// * `PROJECT_ID` can contain letters ([A-Za-z]), numbers ([0-9]),
    ///   hyphens (-), colons (:), or periods (.).
    ///   For more information, see
    ///   [Identifying
    ///   projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects#identifying_projects)
    /// * `LOCATION_ID` is the canonical ID for the queue's location.
    ///   The list of available locations can be obtained by calling
    ///   [ListLocations][google.cloud.location.Locations.ListLocations].
    ///   For more information, see <https://cloud.google.com/about/locations/>.
    /// * `QUEUE_ID` can contain letters ([A-Za-z]), numbers ([0-9]), or
    ///   hyphens (-). The maximum length is 100 characters.
    ///
    /// [google.cloud.tasks.v2.CloudTasks.CreateQueue]: crate::client::CloudTasks::create_queue
    pub name: std::string::String,

    /// Overrides for
    /// [task-level
    /// app_engine_routing][google.cloud.tasks.v2.AppEngineHttpRequest.app_engine_routing].
    /// These settings apply only to
    /// [App Engine tasks][google.cloud.tasks.v2.AppEngineHttpRequest] in this
    /// queue. [Http tasks][google.cloud.tasks.v2.HttpRequest] are not affected.
    ///
    /// If set, `app_engine_routing_override` is used for all
    /// [App Engine tasks][google.cloud.tasks.v2.AppEngineHttpRequest] in the
    /// queue, no matter what the setting is for the [task-level
    /// app_engine_routing][google.cloud.tasks.v2.AppEngineHttpRequest.app_engine_routing].
    ///
    /// [google.cloud.tasks.v2.AppEngineHttpRequest]: crate::model::AppEngineHttpRequest
    /// [google.cloud.tasks.v2.AppEngineHttpRequest.app_engine_routing]: crate::model::AppEngineHttpRequest::app_engine_routing
    /// [google.cloud.tasks.v2.HttpRequest]: crate::model::HttpRequest
    pub app_engine_routing_override: std::option::Option<crate::model::AppEngineRouting>,

    /// Modifies HTTP target for HTTP tasks.
    pub http_target: std::option::Option<crate::model::HttpTarget>,

    /// Rate limits for task dispatches.
    ///
    /// [rate_limits][google.cloud.tasks.v2.Queue.rate_limits] and
    /// [retry_config][google.cloud.tasks.v2.Queue.retry_config] are related
    /// because they both control task attempts. However they control task attempts
    /// in different ways:
    ///
    /// * [rate_limits][google.cloud.tasks.v2.Queue.rate_limits] controls the total
    ///   rate of
    ///   dispatches from a queue (i.e. all traffic dispatched from the
    ///   queue, regardless of whether the dispatch is from a first
    ///   attempt or a retry).
    /// * [retry_config][google.cloud.tasks.v2.Queue.retry_config] controls what
    ///   happens to a
    ///   particular task after its first attempt fails. That is,
    ///   [retry_config][google.cloud.tasks.v2.Queue.retry_config] controls task
    ///   retries (the second attempt, third attempt, etc).
    ///
    /// The queue's actual dispatch rate is the result of:
    ///
    /// * Number of tasks in the queue
    /// * User-specified throttling:
    ///   [rate_limits][google.cloud.tasks.v2.Queue.rate_limits],
    ///   [retry_config][google.cloud.tasks.v2.Queue.retry_config], and the
    ///   [queue's state][google.cloud.tasks.v2.Queue.state].
    /// * System throttling due to `429` (Too Many Requests) or `503` (Service
    ///   Unavailable) responses from the worker, high error rates, or to smooth
    ///   sudden large traffic spikes.
    ///
    /// [google.cloud.tasks.v2.Queue.rate_limits]: crate::model::Queue::rate_limits
    /// [google.cloud.tasks.v2.Queue.retry_config]: crate::model::Queue::retry_config
    /// [google.cloud.tasks.v2.Queue.state]: crate::model::Queue::state
    pub rate_limits: std::option::Option<crate::model::RateLimits>,

    /// Settings that determine the retry behavior.
    ///
    /// * For tasks created using Cloud Tasks: the queue-level retry settings
    ///   apply to all tasks in the queue that were created using Cloud Tasks.
    ///   Retry settings cannot be set on individual tasks.
    /// * For tasks created using the App Engine SDK: the queue-level retry
    ///   settings apply to all tasks in the queue which do not have retry settings
    ///   explicitly set on the task and were created by the App Engine SDK. See
    ///   [App Engine
    ///   documentation](https://cloud.google.com/appengine/docs/standard/python/taskqueue/push/retrying-tasks).
    pub retry_config: std::option::Option<crate::model::RetryConfig>,

    /// Output only. The state of the queue.
    ///
    /// `state` can only be changed by calling
    /// [PauseQueue][google.cloud.tasks.v2.CloudTasks.PauseQueue],
    /// [ResumeQueue][google.cloud.tasks.v2.CloudTasks.ResumeQueue], or uploading
    /// [queue.yaml/xml](https://cloud.google.com/appengine/docs/python/config/queueref).
    /// [UpdateQueue][google.cloud.tasks.v2.CloudTasks.UpdateQueue] cannot be used
    /// to change `state`.
    ///
    /// [google.cloud.tasks.v2.CloudTasks.PauseQueue]: crate::client::CloudTasks::pause_queue
    /// [google.cloud.tasks.v2.CloudTasks.ResumeQueue]: crate::client::CloudTasks::resume_queue
    /// [google.cloud.tasks.v2.CloudTasks.UpdateQueue]: crate::client::CloudTasks::update_queue
    pub state: crate::model::queue::State,

    /// Output only. The last time this queue was purged.
    ///
    /// All tasks that were [created][google.cloud.tasks.v2.Task.create_time]
    /// before this time were purged.
    ///
    /// A queue can be purged using
    /// [PurgeQueue][google.cloud.tasks.v2.CloudTasks.PurgeQueue], the [App Engine
    /// Task Queue SDK, or the Cloud
    /// Console](https://cloud.google.com/appengine/docs/standard/python/taskqueue/push/deleting-tasks-and-queues#purging_all_tasks_from_a_queue).
    ///
    /// Purge time will be truncated to the nearest microsecond. Purge
    /// time will be unset if the queue has never been purged.
    ///
    /// [google.cloud.tasks.v2.CloudTasks.PurgeQueue]: crate::client::CloudTasks::purge_queue
    /// [google.cloud.tasks.v2.Task.create_time]: crate::model::Task::create_time
    pub purge_time: std::option::Option<wkt::Timestamp>,

    /// Configuration options for writing logs to
    /// [Stackdriver Logging](https://cloud.google.com/logging/docs/). If this
    /// field is unset, then no logs are written.
    pub stackdriver_logging_config: std::option::Option<crate::model::StackdriverLoggingConfig>,

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

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

    /// Sets the value of [name][crate::model::Queue::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::Queue;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let queue_id = "queue_id";
    /// let x = Queue::new().set_name(format!("projects/{project_id}/locations/{location_id}/queues/{queue_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 [app_engine_routing_override][crate::model::Queue::app_engine_routing_override].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::Queue;
    /// use google_cloud_tasks_v2::model::AppEngineRouting;
    /// let x = Queue::new().set_app_engine_routing_override(AppEngineRouting::default()/* use setters */);
    /// ```
    pub fn set_app_engine_routing_override<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AppEngineRouting>,
    {
        self.app_engine_routing_override = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

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

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

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

    /// Sets the value of [state][crate::model::Queue::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::Queue;
    /// use google_cloud_tasks_v2::model::queue::State;
    /// let x0 = Queue::new().set_state(State::Running);
    /// let x1 = Queue::new().set_state(State::Paused);
    /// let x2 = Queue::new().set_state(State::Disabled);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::queue::State>>(mut self, v: T) -> Self {
        self.state = v.into();
        self
    }

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

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

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

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

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

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

    /// State of the queue.
    ///
    /// # 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 {
        /// Unspecified state.
        Unspecified,
        /// The queue is running. Tasks can be dispatched.
        ///
        /// If the queue was created using Cloud Tasks and the queue has
        /// had no activity (method calls or task dispatches) for 30 days,
        /// the queue may take a few minutes to re-activate. Some method
        /// calls may return [NOT_FOUND][google.rpc.Code.NOT_FOUND] and
        /// tasks may not be dispatched for a few minutes until the queue
        /// has been re-activated.
        Running,
        /// Tasks are paused by the user. If the queue is paused then Cloud
        /// Tasks will stop delivering tasks from it, but more tasks can
        /// still be added to it by the user.
        Paused,
        /// The queue is disabled.
        ///
        /// A queue becomes `DISABLED` when
        /// [queue.yaml](https://cloud.google.com/appengine/docs/python/config/queueref)
        /// or
        /// [queue.xml](https://cloud.google.com/appengine/docs/standard/java/config/queueref)
        /// is uploaded which does not contain the queue. You cannot directly disable
        /// a queue.
        ///
        /// When a queue is disabled, tasks can still be added to a queue
        /// but the tasks are not dispatched.
        ///
        /// To permanently delete this queue and all of its tasks, call
        /// [DeleteQueue][google.cloud.tasks.v2.CloudTasks.DeleteQueue].
        ///
        /// [google.cloud.tasks.v2.CloudTasks.DeleteQueue]: crate::client::CloudTasks::delete_queue
        Disabled,
        /// 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::Running => std::option::Option::Some(1),
                Self::Paused => std::option::Option::Some(2),
                Self::Disabled => 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("STATE_UNSPECIFIED"),
                Self::Running => std::option::Option::Some("RUNNING"),
                Self::Paused => std::option::Option::Some("PAUSED"),
                Self::Disabled => std::option::Option::Some("DISABLED"),
                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::Running,
                2 => Self::Paused,
                3 => Self::Disabled,
                _ => 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,
                "RUNNING" => Self::Running,
                "PAUSED" => Self::Paused,
                "DISABLED" => Self::Disabled,
                _ => 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::Running => serializer.serialize_i32(1),
                Self::Paused => serializer.serialize_i32(2),
                Self::Disabled => serializer.serialize_i32(3),
                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.tasks.v2.Queue.State",
            ))
        }
    }
}

/// Rate limits.
///
/// This message determines the maximum rate that tasks can be dispatched by a
/// queue, regardless of whether the dispatch is a first task attempt or a retry.
///
/// Note: The debugging command,
/// [RunTask][google.cloud.tasks.v2.CloudTasks.RunTask], will run a task even if
/// the queue has reached its [RateLimits][google.cloud.tasks.v2.RateLimits].
///
/// [google.cloud.tasks.v2.CloudTasks.RunTask]: crate::client::CloudTasks::run_task
/// [google.cloud.tasks.v2.RateLimits]: crate::model::RateLimits
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RateLimits {
    /// The maximum rate at which tasks are dispatched from this queue.
    ///
    /// If unspecified when the queue is created, Cloud Tasks will pick the
    /// default.
    ///
    /// The maximum allowed value is 500.
    ///
    /// This field has the same meaning as
    /// [rate in
    /// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#rate).
    pub max_dispatches_per_second: f64,

    /// Output only. The max burst size.
    ///
    /// Max burst size limits how fast tasks in queue are processed when
    /// many tasks are in the queue and the rate is high. This field
    /// allows the queue to have a high rate so processing starts shortly
    /// after a task is enqueued, but still limits resource usage when
    /// many tasks are enqueued in a short period of time.
    ///
    /// The [token bucket](https://wikipedia.org/wiki/Token_Bucket)
    /// algorithm is used to control the rate of task dispatches. Each
    /// queue has a token bucket that holds tokens, up to the maximum
    /// specified by `max_burst_size`. Each time a task is dispatched, a
    /// token is removed from the bucket. Tasks will be dispatched until
    /// the queue's bucket runs out of tokens. The bucket will be
    /// continuously refilled with new tokens based on
    /// `max_dispatches_per_second`.
    ///
    /// Cloud Tasks automatically sets an appropriate `max_burst_size` based
    /// on the value of `max_dispatches_per_second`. The value is dynamically
    /// optimized to ensure queue stability and throughput. It is generally at
    /// least equal to `max_dispatches_per_second` but might be higher to
    /// accommodate bursts of traffic.
    ///
    /// For queues that were created or updated using
    /// `queue.yaml/xml`, `max_burst_size` is equal to
    /// [bucket_size](https://cloud.google.com/appengine/docs/standard/python/config/queueref#bucket_size).
    /// Since `max_burst_size` is output only, if
    /// [UpdateQueue][google.cloud.tasks.v2.CloudTasks.UpdateQueue] is called on a
    /// queue created by `queue.yaml/xml`, `max_burst_size` will be reset based on
    /// the value of `max_dispatches_per_second`, regardless of whether
    /// `max_dispatches_per_second` is updated.
    ///
    /// [google.cloud.tasks.v2.CloudTasks.UpdateQueue]: crate::client::CloudTasks::update_queue
    pub max_burst_size: i32,

    /// The maximum number of concurrent tasks that Cloud Tasks allows
    /// to be dispatched for this queue. After this threshold has been
    /// reached, Cloud Tasks stops dispatching tasks until the number of
    /// concurrent requests decreases.
    ///
    /// If unspecified when the queue is created, Cloud Tasks will pick the
    /// default.
    ///
    /// The maximum allowed value is 5,000.
    ///
    /// This field has the same meaning as
    /// [max_concurrent_requests in
    /// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#max_concurrent_requests).
    pub max_concurrent_dispatches: i32,

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

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

    /// Sets the value of [max_dispatches_per_second][crate::model::RateLimits::max_dispatches_per_second].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::RateLimits;
    /// let x = RateLimits::new().set_max_dispatches_per_second(42.0);
    /// ```
    pub fn set_max_dispatches_per_second<T: std::convert::Into<f64>>(mut self, v: T) -> Self {
        self.max_dispatches_per_second = v.into();
        self
    }

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

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

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

/// Retry config.
///
/// These settings determine when a failed task attempt is retried.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RetryConfig {
    /// Number of attempts per task, including the first attempt. (If the
    /// first attempt fails, there will be `max_attempts - 1` retries.)
    ///
    /// Must be greater than or equal to -1, which indicates unlimited attempts.
    ///
    /// Cloud Tasks stops retrying only when `max_attempts` and
    /// `max_retry_duration` are both satisfied, or when the task is successfully
    /// executed. When the task has been attempted
    /// `max_attempts` times and when the `max_retry_duration` time has passed, no
    /// further attempts are made, and the task is deleted. If `max_attempts` is
    /// set to -1 and `max_retry_duration` is set to 0, the task is retried
    /// until the [maximum task
    /// retention](https://docs.cloud.google.com/tasks/docs/quotas#limits) limit is
    /// reached.
    ///
    /// If unspecified when the queue is created, Cloud Tasks will pick the
    /// default.
    ///
    /// This field has the same meaning as
    /// [task_retry_limit in
    /// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
    pub max_attempts: i32,

    /// If positive, `max_retry_duration` specifies the time limit for
    /// retrying a failed task, measured from when the task was first
    /// attempted. Once `max_retry_duration` time has passed *and* the
    /// task has been attempted
    /// [max_attempts][google.cloud.tasks.v2.RetryConfig.max_attempts] times, no
    /// further attempts are made and the task is deleted.
    ///
    /// A zero (0) indicates an unlimited duration, up to the
    /// [maximum task
    /// retention](https://docs.cloud.google.com/tasks/docs/quotas#limits) limit.
    ///
    /// The value must be given as a string that indicates the length of time
    /// (in seconds) followed by `s` (for "seconds"). For the maximum possible
    /// value or the format, see the documentation for
    /// [Duration](https://protobuf.dev/reference/protobuf/google.protobuf/#duration).
    /// `max_retry_duration` will be truncated to the nearest second.
    ///
    /// If unspecified when the queue is created, Cloud Tasks will pick the
    /// default.
    ///
    /// This field has the same meaning as
    /// [task_age_limit in
    /// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
    ///
    /// [google.cloud.tasks.v2.RetryConfig.max_attempts]: crate::model::RetryConfig::max_attempts
    pub max_retry_duration: std::option::Option<wkt::Duration>,

    /// A task will be [scheduled][google.cloud.tasks.v2.Task.schedule_time] for
    /// retry between [min_backoff][google.cloud.tasks.v2.RetryConfig.min_backoff]
    /// and [max_backoff][google.cloud.tasks.v2.RetryConfig.max_backoff] duration
    /// after it fails, if the queue's
    /// [RetryConfig][google.cloud.tasks.v2.RetryConfig] specifies that the task
    /// should be retried.
    ///
    /// The value must be given as a string that indicates the length of time
    /// (in seconds) followed by `s` (for "seconds"). For more information on the
    /// format, see the documentation for
    /// [Duration](https://protobuf.dev/reference/protobuf/google.protobuf/#duration).
    /// `min_backoff` will be truncated to the nearest second.
    ///
    /// If unspecified when the queue is created, Cloud Tasks will pick the
    /// default.
    ///
    /// This field has the same meaning as
    /// [min_backoff_seconds in
    /// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
    ///
    /// [google.cloud.tasks.v2.RetryConfig]: crate::model::RetryConfig
    /// [google.cloud.tasks.v2.RetryConfig.max_backoff]: crate::model::RetryConfig::max_backoff
    /// [google.cloud.tasks.v2.RetryConfig.min_backoff]: crate::model::RetryConfig::min_backoff
    /// [google.cloud.tasks.v2.Task.schedule_time]: crate::model::Task::schedule_time
    pub min_backoff: std::option::Option<wkt::Duration>,

    /// A task will be [scheduled][google.cloud.tasks.v2.Task.schedule_time] for
    /// retry between [min_backoff][google.cloud.tasks.v2.RetryConfig.min_backoff]
    /// and [max_backoff][google.cloud.tasks.v2.RetryConfig.max_backoff] duration
    /// after it fails, if the queue's
    /// [RetryConfig][google.cloud.tasks.v2.RetryConfig] specifies that the task
    /// should be retried.
    ///
    /// The value must be given as a string that indicates the length of time
    /// (in seconds) followed by `s` (for "seconds"). For more information on the
    /// format, see the documentation for
    /// [Duration](https://protobuf.dev/reference/protobuf/google.protobuf/#duration).
    /// `max_backoff` will be truncated to the nearest second.
    ///
    /// If unspecified when the queue is created, Cloud Tasks will pick the
    /// default.
    ///
    /// This field has the same meaning as
    /// [max_backoff_seconds in
    /// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
    ///
    /// [google.cloud.tasks.v2.RetryConfig]: crate::model::RetryConfig
    /// [google.cloud.tasks.v2.RetryConfig.max_backoff]: crate::model::RetryConfig::max_backoff
    /// [google.cloud.tasks.v2.RetryConfig.min_backoff]: crate::model::RetryConfig::min_backoff
    /// [google.cloud.tasks.v2.Task.schedule_time]: crate::model::Task::schedule_time
    pub max_backoff: std::option::Option<wkt::Duration>,

    /// The time between retries will double `max_doublings` times.
    ///
    /// A task's retry interval starts at
    /// [min_backoff][google.cloud.tasks.v2.RetryConfig.min_backoff], then doubles
    /// `max_doublings` times, then increases linearly, and finally
    /// retries at intervals of
    /// [max_backoff][google.cloud.tasks.v2.RetryConfig.max_backoff] up to
    /// [max_attempts][google.cloud.tasks.v2.RetryConfig.max_attempts] times.
    ///
    /// For example, if
    /// [min_backoff][google.cloud.tasks.v2.RetryConfig.min_backoff] is 10s,
    /// [max_backoff][google.cloud.tasks.v2.RetryConfig.max_backoff] is 300s, and
    /// `max_doublings` is 3, then the a task will first be retried in
    /// 10s. The retry interval will double three times, and then
    /// increase linearly by 2^3 * 10s.  Finally, the task will retry at
    /// intervals of [max_backoff][google.cloud.tasks.v2.RetryConfig.max_backoff]
    /// until the task has been attempted
    /// [max_attempts][google.cloud.tasks.v2.RetryConfig.max_attempts] times. Thus,
    /// the requests will retry at 10s, 20s, 40s, 80s, 160s, 240s, 300s, 300s, ....
    ///
    /// If unspecified when the queue is created, Cloud Tasks will pick the
    /// default.
    ///
    /// This field has the same meaning as
    /// [max_doublings in
    /// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
    ///
    /// [google.cloud.tasks.v2.RetryConfig.max_attempts]: crate::model::RetryConfig::max_attempts
    /// [google.cloud.tasks.v2.RetryConfig.max_backoff]: crate::model::RetryConfig::max_backoff
    /// [google.cloud.tasks.v2.RetryConfig.min_backoff]: crate::model::RetryConfig::min_backoff
    pub max_doublings: i32,

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

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

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

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

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

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

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

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

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

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

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

/// Configuration options for writing logs to
/// [Stackdriver Logging](https://cloud.google.com/logging/docs/).
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StackdriverLoggingConfig {
    /// Specifies the fraction of operations to write to
    /// [Stackdriver Logging](https://cloud.google.com/logging/docs/).
    /// This field may contain any value between 0.0 and 1.0, inclusive.
    /// 0.0 is the default and means that no operations are logged.
    pub sampling_ratio: f64,

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

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

    /// Sets the value of [sampling_ratio][crate::model::StackdriverLoggingConfig::sampling_ratio].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::StackdriverLoggingConfig;
    /// let x = StackdriverLoggingConfig::new().set_sampling_ratio(42.0);
    /// ```
    pub fn set_sampling_ratio<T: std::convert::Into<f64>>(mut self, v: T) -> Self {
        self.sampling_ratio = v.into();
        self
    }
}

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

/// PathOverride.
///
/// Path message defines path override for HTTP targets.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PathOverride {
    /// The URI path (e.g., /users/1234). Default is an empty string.
    pub path: std::string::String,

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

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

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

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

/// QueryOverride.
///
/// Query message defines query override for HTTP targets.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct QueryOverride {
    /// The query parameters (e.g., qparam1=123&qparam2=456). Default is an empty
    /// string.
    pub query_params: std::string::String,

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

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

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

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

/// URI Override.
///
/// When specified, all the HTTP tasks inside the queue will be partially or
/// fully overridden depending on the configured values.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UriOverride {
    /// Scheme override.
    ///
    /// When specified, the task URI scheme is replaced by the provided value (HTTP
    /// or HTTPS).
    pub scheme: std::option::Option<crate::model::uri_override::Scheme>,

    /// Host override.
    ///
    /// When specified, replaces the host part of the task URL. For example,
    /// if the task URL is "<https://www.google.com>," and host value is set to
    /// "example.net", the overridden URI will be changed to "<https://example.net>."
    /// Host value cannot be an empty string (INVALID_ARGUMENT).
    pub host: std::option::Option<std::string::String>,

    /// Port override.
    ///
    /// When specified, replaces the port part of the task URI. For instance,
    /// for a URI `https://www.example.com/example` and port=123, the overridden
    /// URI becomes "<https://www.example.com>:123/example". Note that the port value
    /// must be a positive integer. Setting the port to 0 (Zero) clears the URI
    /// port.
    pub port: std::option::Option<i64>,

    /// URI path.
    ///
    /// When specified, replaces the existing path of the task URL. Setting the
    /// path value to an empty string clears the URI path segment.
    pub path_override: std::option::Option<crate::model::PathOverride>,

    /// URI query.
    ///
    /// When specified, replaces the query part of the task URI. Setting the
    /// query value to an empty string clears the URI query segment.
    pub query_override: std::option::Option<crate::model::QueryOverride>,

    /// URI Override Enforce Mode
    ///
    /// When specified, determines the Target UriOverride mode. If not specified,
    /// it defaults to ALWAYS.
    pub uri_override_enforce_mode: crate::model::uri_override::UriOverrideEnforceMode,

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

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

    /// Sets the value of [scheme][crate::model::UriOverride::scheme].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::UriOverride;
    /// use google_cloud_tasks_v2::model::uri_override::Scheme;
    /// let x0 = UriOverride::new().set_scheme(Scheme::Http);
    /// let x1 = UriOverride::new().set_scheme(Scheme::Https);
    /// ```
    pub fn set_scheme<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::uri_override::Scheme>,
    {
        self.scheme = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [scheme][crate::model::UriOverride::scheme].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::UriOverride;
    /// use google_cloud_tasks_v2::model::uri_override::Scheme;
    /// let x0 = UriOverride::new().set_or_clear_scheme(Some(Scheme::Http));
    /// let x1 = UriOverride::new().set_or_clear_scheme(Some(Scheme::Https));
    /// let x_none = UriOverride::new().set_or_clear_scheme(None::<Scheme>);
    /// ```
    pub fn set_or_clear_scheme<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::uri_override::Scheme>,
    {
        self.scheme = v.map(|x| x.into());
        self
    }

    /// Sets the value of [host][crate::model::UriOverride::host].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::UriOverride;
    /// let x = UriOverride::new().set_host("example");
    /// ```
    pub fn set_host<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.host = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [host][crate::model::UriOverride::host].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::UriOverride;
    /// let x = UriOverride::new().set_or_clear_host(Some("example"));
    /// let x = UriOverride::new().set_or_clear_host(None::<String>);
    /// ```
    pub fn set_or_clear_host<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.host = v.map(|x| x.into());
        self
    }

    /// Sets the value of [port][crate::model::UriOverride::port].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::UriOverride;
    /// let x = UriOverride::new().set_port(42);
    /// ```
    pub fn set_port<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i64>,
    {
        self.port = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [port][crate::model::UriOverride::port].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::UriOverride;
    /// let x = UriOverride::new().set_or_clear_port(Some(42));
    /// let x = UriOverride::new().set_or_clear_port(None::<i32>);
    /// ```
    pub fn set_or_clear_port<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i64>,
    {
        self.port = v.map(|x| x.into());
        self
    }

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

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

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

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

    /// Sets the value of [uri_override_enforce_mode][crate::model::UriOverride::uri_override_enforce_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::UriOverride;
    /// use google_cloud_tasks_v2::model::uri_override::UriOverrideEnforceMode;
    /// let x0 = UriOverride::new().set_uri_override_enforce_mode(UriOverrideEnforceMode::IfNotExists);
    /// let x1 = UriOverride::new().set_uri_override_enforce_mode(UriOverrideEnforceMode::Always);
    /// ```
    pub fn set_uri_override_enforce_mode<
        T: std::convert::Into<crate::model::uri_override::UriOverrideEnforceMode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.uri_override_enforce_mode = v.into();
        self
    }
}

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

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

    /// The Scheme for an HTTP request. By default, it is HTTPS.
    ///
    /// # 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 Scheme {
        /// Scheme unspecified. Defaults to HTTPS.
        Unspecified,
        /// Convert the scheme to HTTP, e.g., `https://www.example.com` will change
        /// to `http://www.example.com`.
        Http,
        /// Convert the scheme to HTTPS, e.g., `http://www.example.com` will change
        /// to `https://www.example.com`.
        Https,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Scheme::value] or
        /// [Scheme::name].
        UnknownValue(scheme::UnknownValue),
    }

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

    impl Scheme {
        /// 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::Http => std::option::Option::Some(1),
                Self::Https => 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("SCHEME_UNSPECIFIED"),
                Self::Http => std::option::Option::Some("HTTP"),
                Self::Https => std::option::Option::Some("HTTPS"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

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

    impl std::convert::From<&str> for Scheme {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "SCHEME_UNSPECIFIED" => Self::Unspecified,
                "HTTP" => Self::Http,
                "HTTPS" => Self::Https,
                _ => Self::UnknownValue(scheme::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

    /// UriOverrideEnforceMode defines when the URI override is enforced.
    ///
    /// # 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 UriOverrideEnforceMode {
        /// UriOverrideEnforceMode Unspecified. Defaults to ALWAYS.
        Unspecified,
        /// In the IF_NOT_EXISTS mode, queue-level configuration is only
        /// applied where task-level configuration does not exist.
        IfNotExists,
        /// In the ALWAYS mode, queue-level configuration overrides all
        /// task-level configuration
        Always,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [UriOverrideEnforceMode::value] or
        /// [UriOverrideEnforceMode::name].
        UnknownValue(uri_override_enforce_mode::UnknownValue),
    }

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

    impl UriOverrideEnforceMode {
        /// 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::IfNotExists => std::option::Option::Some(1),
                Self::Always => 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("URI_OVERRIDE_ENFORCE_MODE_UNSPECIFIED")
                }
                Self::IfNotExists => std::option::Option::Some("IF_NOT_EXISTS"),
                Self::Always => std::option::Option::Some("ALWAYS"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

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

    impl std::convert::From<&str> for UriOverrideEnforceMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "URI_OVERRIDE_ENFORCE_MODE_UNSPECIFIED" => Self::Unspecified,
                "IF_NOT_EXISTS" => Self::IfNotExists,
                "ALWAYS" => Self::Always,
                _ => Self::UnknownValue(uri_override_enforce_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// HTTP target.
///
/// When specified at the [Queue][google.cloud.tasks.v2.Queue] level, all tasks
/// with [HttpRequest][google.cloud.tasks.v2.HttpRequest] are overridden
/// according to the target.
///
/// [google.cloud.tasks.v2.HttpRequest]: crate::model::HttpRequest
/// [google.cloud.tasks.v2.Queue]: crate::model::Queue
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct HttpTarget {
    /// URI override.
    ///
    /// When specified, overrides the execution URI for all the tasks in the queue.
    pub uri_override: std::option::Option<crate::model::UriOverride>,

    /// The HTTP method to use for the request.
    ///
    /// When specified, it overrides
    /// [HttpRequest][google.cloud.tasks.v2.HttpTarget.http_method] for the task.
    /// Note that if the value is set to [HttpMethod][GET] the [HttpRequest][body]
    /// of the task will be ignored at execution time.
    ///
    /// [google.cloud.tasks.v2.HttpTarget.http_method]: crate::model::HttpTarget::http_method
    pub http_method: crate::model::HttpMethod,

    /// HTTP target headers.
    ///
    /// This map contains the header field names and values.
    /// Headers will be set when running the
    /// [CreateTask][google.cloud.tasks.v2.CloudTasks.CreateTask] and/or
    /// [BufferTask][google.cloud.tasks.v2.CloudTasks.BufferTask].
    ///
    /// These headers represent a subset of the headers that will be configured for
    /// the task's HTTP request. Some HTTP request headers will be ignored or
    /// replaced.
    ///
    /// A partial list of headers that will be ignored or replaced is:
    ///
    /// * Several predefined headers, prefixed with "X-CloudTasks-", can
    ///   be used to define properties of the task.
    /// * Host: This will be computed by Cloud Tasks and derived from
    ///   [HttpRequest.url][google.cloud.tasks.v2.Target.HttpRequest.url].
    /// * Content-Length: This will be computed by Cloud Tasks.
    ///
    /// `Content-Type` won't be set by Cloud Tasks. You can explicitly set
    /// `Content-Type` to a media type when the
    /// [task is created][google.cloud.tasks.v2.CloudTasks.CreateTask].
    /// For example, `Content-Type` can be set to `"application/octet-stream"` or
    /// `"application/json"`. The default value is set to `"application/json"`.
    ///
    /// * User-Agent: This will be set to `"Google-Cloud-Tasks"`.
    ///
    /// Headers which can have multiple values (according to RFC2616) can be
    /// specified using comma-separated values.
    ///
    /// The size of the headers must be less than 80KB.
    /// Queue-level headers to override headers of all the tasks in the queue.
    ///
    /// Do not put business sensitive or personally identifying data in the HTTP
    /// Header Override Configuration or other similar fields in accordance with
    /// Section 12 (Resource Fields) of the
    /// [Service Specific Terms](https://cloud.google.com/terms/service-terms).
    ///
    /// [google.cloud.tasks.v2.CloudTasks.CreateTask]: crate::client::CloudTasks::create_task
    pub header_overrides: std::vec::Vec<crate::model::http_target::HeaderOverride>,

    /// The mode for generating an `Authorization` header for HTTP requests.
    ///
    /// If specified, all `Authorization` headers in the
    /// [HttpRequest.headers][google.cloud.tasks.v2.HttpRequest.headers] field are
    /// overridden.
    ///
    /// [google.cloud.tasks.v2.HttpRequest.headers]: crate::model::HttpRequest::headers
    pub authorization_header: std::option::Option<crate::model::http_target::AuthorizationHeader>,

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

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

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

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

    /// Sets the value of [http_method][crate::model::HttpTarget::http_method].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::HttpTarget;
    /// use google_cloud_tasks_v2::model::HttpMethod;
    /// let x0 = HttpTarget::new().set_http_method(HttpMethod::Post);
    /// let x1 = HttpTarget::new().set_http_method(HttpMethod::Get);
    /// let x2 = HttpTarget::new().set_http_method(HttpMethod::Head);
    /// ```
    pub fn set_http_method<T: std::convert::Into<crate::model::HttpMethod>>(
        mut self,
        v: T,
    ) -> Self {
        self.http_method = v.into();
        self
    }

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

    /// Sets the value of [authorization_header][crate::model::HttpTarget::authorization_header].
    ///
    /// Note that all the setters affecting `authorization_header` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::HttpTarget;
    /// use google_cloud_tasks_v2::model::OAuthToken;
    /// let x = HttpTarget::new().set_authorization_header(Some(
    ///     google_cloud_tasks_v2::model::http_target::AuthorizationHeader::OauthToken(OAuthToken::default().into())));
    /// ```
    pub fn set_authorization_header<
        T: std::convert::Into<std::option::Option<crate::model::http_target::AuthorizationHeader>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.authorization_header = v.into();
        self
    }

    /// The value of [authorization_header][crate::model::HttpTarget::authorization_header]
    /// if it holds a `OauthToken`, `None` if the field is not set or
    /// holds a different branch.
    pub fn oauth_token(&self) -> std::option::Option<&std::boxed::Box<crate::model::OAuthToken>> {
        #[allow(unreachable_patterns)]
        self.authorization_header.as_ref().and_then(|v| match v {
            crate::model::http_target::AuthorizationHeader::OauthToken(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [authorization_header][crate::model::HttpTarget::authorization_header]
    /// to hold a `OauthToken`.
    ///
    /// Note that all the setters affecting `authorization_header` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::HttpTarget;
    /// use google_cloud_tasks_v2::model::OAuthToken;
    /// let x = HttpTarget::new().set_oauth_token(OAuthToken::default()/* use setters */);
    /// assert!(x.oauth_token().is_some());
    /// assert!(x.oidc_token().is_none());
    /// ```
    pub fn set_oauth_token<T: std::convert::Into<std::boxed::Box<crate::model::OAuthToken>>>(
        mut self,
        v: T,
    ) -> Self {
        self.authorization_header = std::option::Option::Some(
            crate::model::http_target::AuthorizationHeader::OauthToken(v.into()),
        );
        self
    }

    /// The value of [authorization_header][crate::model::HttpTarget::authorization_header]
    /// if it holds a `OidcToken`, `None` if the field is not set or
    /// holds a different branch.
    pub fn oidc_token(&self) -> std::option::Option<&std::boxed::Box<crate::model::OidcToken>> {
        #[allow(unreachable_patterns)]
        self.authorization_header.as_ref().and_then(|v| match v {
            crate::model::http_target::AuthorizationHeader::OidcToken(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [authorization_header][crate::model::HttpTarget::authorization_header]
    /// to hold a `OidcToken`.
    ///
    /// Note that all the setters affecting `authorization_header` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::HttpTarget;
    /// use google_cloud_tasks_v2::model::OidcToken;
    /// let x = HttpTarget::new().set_oidc_token(OidcToken::default()/* use setters */);
    /// assert!(x.oidc_token().is_some());
    /// assert!(x.oauth_token().is_none());
    /// ```
    pub fn set_oidc_token<T: std::convert::Into<std::boxed::Box<crate::model::OidcToken>>>(
        mut self,
        v: T,
    ) -> Self {
        self.authorization_header = std::option::Option::Some(
            crate::model::http_target::AuthorizationHeader::OidcToken(v.into()),
        );
        self
    }
}

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

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

    /// Defines a header message. A header can have a key and a value.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Header {
        /// The Key of the header.
        pub key: std::string::String,

        /// The Value of the header.
        pub value: std::string::String,

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

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

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

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

    impl wkt::message::Message for Header {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.tasks.v2.HttpTarget.Header"
        }
    }

    /// Wraps the Header object.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct HeaderOverride {
        /// Header embodying a key and a value.
        ///
        /// Do not put business sensitive or personally identifying data in the HTTP
        /// Header Override Configuration or other similar fields in accordance with
        /// Section 12 (Resource Fields) of the
        /// [Service Specific Terms](https://cloud.google.com/terms/service-terms).
        pub header: std::option::Option<crate::model::http_target::Header>,

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

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

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

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

    impl wkt::message::Message for HeaderOverride {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.tasks.v2.HttpTarget.HeaderOverride"
        }
    }

    /// The mode for generating an `Authorization` header for HTTP requests.
    ///
    /// If specified, all `Authorization` headers in the
    /// [HttpRequest.headers][google.cloud.tasks.v2.HttpRequest.headers] field are
    /// overridden.
    ///
    /// [google.cloud.tasks.v2.HttpRequest.headers]: crate::model::HttpRequest::headers
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum AuthorizationHeader {
        /// If specified, an
        /// [OAuth token](https://developers.google.com/identity/protocols/OAuth2)
        /// is generated and attached as the `Authorization` header in the HTTP
        /// request.
        ///
        /// This type of authorization should generally be used only when calling
        /// Google APIs hosted on *.googleapis.com. Note that both the service
        /// account email and the scope MUST be specified when using the queue-level
        /// authorization override.
        OauthToken(std::boxed::Box<crate::model::OAuthToken>),
        /// If specified, an
        /// [OIDC](https://developers.google.com/identity/protocols/OpenIDConnect)
        /// token is generated and attached as an `Authorization` header in the
        /// HTTP request.
        ///
        /// This type of authorization can be used for many scenarios, including
        /// calling Cloud Run, or endpoints where you intend to validate the token
        /// yourself. Note that both the service account email and the audience MUST
        /// be specified when using the queue-level authorization override.
        OidcToken(std::boxed::Box<crate::model::OidcToken>),
    }
}

/// HTTP request.
///
/// The task will be pushed to the worker as an HTTP request. If the worker
/// or the redirected worker acknowledges the task by returning a successful HTTP
/// response code ([`200` - `299`]), the task will be removed from the queue. If
/// any other HTTP response code is returned or no response is received, the
/// task will be retried according to the following:
///
/// * User-specified throttling: [retry
///   configuration][google.cloud.tasks.v2.Queue.retry_config],
///   [rate limits][google.cloud.tasks.v2.Queue.rate_limits], and the [queue's
///   state][google.cloud.tasks.v2.Queue.state].
///
/// * System throttling: To prevent the worker from overloading, Cloud Tasks may
///   temporarily reduce the queue's effective rate. User-specified settings
///   will not be changed.
///
///
/// System throttling happens because:
///
/// * Cloud Tasks backs off on all errors. Normally the backoff specified in
///   [rate limits][google.cloud.tasks.v2.Queue.rate_limits] will be used. But
///   if the worker returns `429` (Too Many Requests), `503` (Service
///   Unavailable), or the rate of errors is high, Cloud Tasks will use a
///   higher backoff rate. The retry specified in the `Retry-After` HTTP
///   response header is considered.
///
/// * To prevent traffic spikes and to smooth sudden increases in traffic,
///   dispatches ramp up slowly when the queue is newly created or idle and
///   if large numbers of tasks suddenly become available to dispatch (due to
///   spikes in create task rates, the queue being unpaused, or many tasks
///   that are scheduled at the same time).
///
///
/// [google.cloud.tasks.v2.Queue.rate_limits]: crate::model::Queue::rate_limits
/// [google.cloud.tasks.v2.Queue.retry_config]: crate::model::Queue::retry_config
/// [google.cloud.tasks.v2.Queue.state]: crate::model::Queue::state
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct HttpRequest {
    /// Required. The full url path that the request will be sent to.
    ///
    /// This string must begin with either "http://" or "https://". Some examples
    /// are: `<http://acme.com>` and `<https://acme.com/sales:8080>`. Cloud Tasks will
    /// encode some characters for safety and compatibility. The maximum allowed
    /// URL length is 2083 characters after encoding.
    ///
    /// The `Location` header response from a redirect response [`300` - `399`]
    /// may be followed. The redirect is not counted as a separate attempt.
    pub url: std::string::String,

    /// The HTTP method to use for the request. The default is POST.
    pub http_method: crate::model::HttpMethod,

    /// HTTP request headers.
    ///
    /// This map contains the header field names and values.
    /// Headers can be set when the
    /// [task is created][google.cloud.tasks.v2.CloudTasks.CreateTask].
    ///
    /// These headers represent a subset of the headers that will accompany the
    /// task's HTTP request. Some HTTP request headers will be ignored or replaced.
    ///
    /// A partial list of headers that will be ignored or replaced is:
    ///
    /// * Host: This will be computed by Cloud Tasks and derived from
    ///   [HttpRequest.url][google.cloud.tasks.v2.HttpRequest.url].
    /// * Content-Length: This will be computed by Cloud Tasks.
    /// * User-Agent: This will be set to `"Google-Cloud-Tasks"`.
    /// * `X-Google-*`: Google use only.
    /// * `X-AppEngine-*`: Google use only.
    ///
    /// `Content-Type` won't be set by Cloud Tasks. You can explicitly set
    /// `Content-Type` to a media type when the
    /// [task is created][google.cloud.tasks.v2.CloudTasks.CreateTask].
    /// For example, `Content-Type` can be set to `"application/octet-stream"` or
    /// `"application/json"`.
    ///
    /// Headers which can have multiple values (according to RFC2616) can be
    /// specified using comma-separated values.
    ///
    /// The size of the headers must be less than 80KB.
    ///
    /// [google.cloud.tasks.v2.CloudTasks.CreateTask]: crate::client::CloudTasks::create_task
    /// [google.cloud.tasks.v2.HttpRequest.url]: crate::model::HttpRequest::url
    pub headers: std::collections::HashMap<std::string::String, std::string::String>,

    /// HTTP request body.
    ///
    /// A request body is allowed only if the
    /// [HTTP method][google.cloud.tasks.v2.HttpRequest.http_method] is POST, PUT,
    /// or PATCH. It is an error to set body on a task with an incompatible
    /// [HttpMethod][google.cloud.tasks.v2.HttpMethod].
    ///
    /// [google.cloud.tasks.v2.HttpMethod]: crate::model::HttpMethod
    /// [google.cloud.tasks.v2.HttpRequest.http_method]: crate::model::HttpRequest::http_method
    pub body: ::bytes::Bytes,

    /// The mode for generating an `Authorization` header for HTTP requests.
    ///
    /// If specified at the [Queue][google.cloud.tasks.v2.Queue] level, all
    /// `Authorization` headers in the
    /// [HttpRequest.headers][google.cloud.tasks.v2.HttpRequest.headers] field are
    /// overridden.
    ///
    /// [google.cloud.tasks.v2.HttpRequest.headers]: crate::model::HttpRequest::headers
    /// [google.cloud.tasks.v2.Queue]: crate::model::Queue
    pub authorization_header: std::option::Option<crate::model::http_request::AuthorizationHeader>,

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

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

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

    /// Sets the value of [http_method][crate::model::HttpRequest::http_method].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::HttpRequest;
    /// use google_cloud_tasks_v2::model::HttpMethod;
    /// let x0 = HttpRequest::new().set_http_method(HttpMethod::Post);
    /// let x1 = HttpRequest::new().set_http_method(HttpMethod::Get);
    /// let x2 = HttpRequest::new().set_http_method(HttpMethod::Head);
    /// ```
    pub fn set_http_method<T: std::convert::Into<crate::model::HttpMethod>>(
        mut self,
        v: T,
    ) -> Self {
        self.http_method = v.into();
        self
    }

    /// Sets the value of [headers][crate::model::HttpRequest::headers].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::HttpRequest;
    /// let x = HttpRequest::new().set_headers([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_headers<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.headers = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

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

    /// Sets the value of [authorization_header][crate::model::HttpRequest::authorization_header].
    ///
    /// Note that all the setters affecting `authorization_header` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::HttpRequest;
    /// use google_cloud_tasks_v2::model::OAuthToken;
    /// let x = HttpRequest::new().set_authorization_header(Some(
    ///     google_cloud_tasks_v2::model::http_request::AuthorizationHeader::OauthToken(OAuthToken::default().into())));
    /// ```
    pub fn set_authorization_header<
        T: std::convert::Into<std::option::Option<crate::model::http_request::AuthorizationHeader>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.authorization_header = v.into();
        self
    }

    /// The value of [authorization_header][crate::model::HttpRequest::authorization_header]
    /// if it holds a `OauthToken`, `None` if the field is not set or
    /// holds a different branch.
    pub fn oauth_token(&self) -> std::option::Option<&std::boxed::Box<crate::model::OAuthToken>> {
        #[allow(unreachable_patterns)]
        self.authorization_header.as_ref().and_then(|v| match v {
            crate::model::http_request::AuthorizationHeader::OauthToken(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [authorization_header][crate::model::HttpRequest::authorization_header]
    /// to hold a `OauthToken`.
    ///
    /// Note that all the setters affecting `authorization_header` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::HttpRequest;
    /// use google_cloud_tasks_v2::model::OAuthToken;
    /// let x = HttpRequest::new().set_oauth_token(OAuthToken::default()/* use setters */);
    /// assert!(x.oauth_token().is_some());
    /// assert!(x.oidc_token().is_none());
    /// ```
    pub fn set_oauth_token<T: std::convert::Into<std::boxed::Box<crate::model::OAuthToken>>>(
        mut self,
        v: T,
    ) -> Self {
        self.authorization_header = std::option::Option::Some(
            crate::model::http_request::AuthorizationHeader::OauthToken(v.into()),
        );
        self
    }

    /// The value of [authorization_header][crate::model::HttpRequest::authorization_header]
    /// if it holds a `OidcToken`, `None` if the field is not set or
    /// holds a different branch.
    pub fn oidc_token(&self) -> std::option::Option<&std::boxed::Box<crate::model::OidcToken>> {
        #[allow(unreachable_patterns)]
        self.authorization_header.as_ref().and_then(|v| match v {
            crate::model::http_request::AuthorizationHeader::OidcToken(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [authorization_header][crate::model::HttpRequest::authorization_header]
    /// to hold a `OidcToken`.
    ///
    /// Note that all the setters affecting `authorization_header` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::HttpRequest;
    /// use google_cloud_tasks_v2::model::OidcToken;
    /// let x = HttpRequest::new().set_oidc_token(OidcToken::default()/* use setters */);
    /// assert!(x.oidc_token().is_some());
    /// assert!(x.oauth_token().is_none());
    /// ```
    pub fn set_oidc_token<T: std::convert::Into<std::boxed::Box<crate::model::OidcToken>>>(
        mut self,
        v: T,
    ) -> Self {
        self.authorization_header = std::option::Option::Some(
            crate::model::http_request::AuthorizationHeader::OidcToken(v.into()),
        );
        self
    }
}

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

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

    /// The mode for generating an `Authorization` header for HTTP requests.
    ///
    /// If specified at the [Queue][google.cloud.tasks.v2.Queue] level, all
    /// `Authorization` headers in the
    /// [HttpRequest.headers][google.cloud.tasks.v2.HttpRequest.headers] field are
    /// overridden.
    ///
    /// [google.cloud.tasks.v2.HttpRequest.headers]: crate::model::HttpRequest::headers
    /// [google.cloud.tasks.v2.Queue]: crate::model::Queue
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum AuthorizationHeader {
        /// If specified, an
        /// [OAuth token](https://developers.google.com/identity/protocols/OAuth2)
        /// will be generated and attached as an `Authorization` header in the HTTP
        /// request.
        ///
        /// This type of authorization should generally only be used when calling
        /// Google APIs hosted on *.googleapis.com.
        OauthToken(std::boxed::Box<crate::model::OAuthToken>),
        /// If specified, an
        /// [OIDC](https://developers.google.com/identity/protocols/OpenIDConnect)
        /// token will be generated and attached as an `Authorization` header in the
        /// HTTP request.
        ///
        /// This type of authorization can be used for many scenarios, including
        /// calling Cloud Run, or endpoints where you intend to validate the token
        /// yourself.
        OidcToken(std::boxed::Box<crate::model::OidcToken>),
    }
}

/// App Engine HTTP request.
///
/// The message defines the HTTP request that is sent to an App Engine app when
/// the task is dispatched.
///
/// Using [AppEngineHttpRequest][google.cloud.tasks.v2.AppEngineHttpRequest]
/// requires
/// [`appengine.applications.get`](https://cloud.google.com/appengine/docs/admin-api/access-control)
/// Google IAM permission for the project
/// and the following scope:
///
/// `<https://www.googleapis.com/auth/cloud-platform>`
///
/// The task will be delivered to the App Engine app which belongs to the same
/// project as the queue. For more information, see
/// [How Requests are
/// Routed](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed)
/// and how routing is affected by
/// [dispatch
/// files](https://cloud.google.com/appengine/docs/python/config/dispatchref).
/// Traffic is encrypted during transport and never leaves Google datacenters.
/// Because this traffic is carried over a communication mechanism internal to
/// Google, you cannot explicitly set the protocol (for example, HTTP or HTTPS).
/// The request to the handler, however, will appear to have used the HTTP
/// protocol.
///
/// The [AppEngineRouting][google.cloud.tasks.v2.AppEngineRouting] used to
/// construct the URL that the task is delivered to can be set at the queue-level
/// or task-level:
///
/// * If [app_engine_routing_override is set on the
///   queue][google.cloud.tasks.v2.Queue.app_engine_routing_override], this value
///   is used for all tasks in the queue, no matter what the setting is for the
///   [task-level
///   app_engine_routing][google.cloud.tasks.v2.AppEngineHttpRequest.app_engine_routing].
///
/// The `url` that the task will be sent to is:
///
/// * `url =` [host][google.cloud.tasks.v2.AppEngineRouting.host] `+`
///   [relative_uri][google.cloud.tasks.v2.AppEngineHttpRequest.relative_uri]
///
/// Tasks can be dispatched to secure app handlers, unsecure app handlers, and
/// URIs restricted with
/// [`login:
/// admin`](https://cloud.google.com/appengine/docs/standard/python/config/appref).
/// Because tasks are not run as any user, they cannot be dispatched to URIs
/// restricted with
/// [`login:
/// required`](https://cloud.google.com/appengine/docs/standard/python/config/appref)
/// Task dispatches also do not follow redirects.
///
/// The task attempt has succeeded if the app's request handler returns an HTTP
/// response code in the range [`200` - `299`]. The task attempt has failed if
/// the app's handler returns a non-2xx response code or Cloud Tasks does
/// not receive response before the
/// [deadline][google.cloud.tasks.v2.Task.dispatch_deadline]. Failed tasks will
/// be retried according to the [retry
/// configuration][google.cloud.tasks.v2.Queue.retry_config]. `503` (Service
/// Unavailable) is considered an App Engine system error instead of an
/// application error and will cause Cloud Tasks' traffic congestion control to
/// temporarily throttle the queue's dispatches. Unlike other types of task
/// targets, a `429` (Too Many Requests) response from an app handler does not
/// cause traffic congestion control to throttle the queue.
///
/// [google.cloud.tasks.v2.AppEngineHttpRequest]: crate::model::AppEngineHttpRequest
/// [google.cloud.tasks.v2.AppEngineHttpRequest.app_engine_routing]: crate::model::AppEngineHttpRequest::app_engine_routing
/// [google.cloud.tasks.v2.AppEngineHttpRequest.relative_uri]: crate::model::AppEngineHttpRequest::relative_uri
/// [google.cloud.tasks.v2.AppEngineRouting]: crate::model::AppEngineRouting
/// [google.cloud.tasks.v2.AppEngineRouting.host]: crate::model::AppEngineRouting::host
/// [google.cloud.tasks.v2.Queue.app_engine_routing_override]: crate::model::Queue::app_engine_routing_override
/// [google.cloud.tasks.v2.Queue.retry_config]: crate::model::Queue::retry_config
/// [google.cloud.tasks.v2.Task.dispatch_deadline]: crate::model::Task::dispatch_deadline
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AppEngineHttpRequest {
    /// The HTTP method to use for the request. The default is POST.
    ///
    /// The app's request handler for the task's target URL must be able to handle
    /// HTTP requests with this http_method, otherwise the task attempt fails with
    /// error code 405 (Method Not Allowed). See [Writing a push task request
    /// handler](https://cloud.google.com/appengine/docs/java/taskqueue/push/creating-handlers#writing_a_push_task_request_handler)
    /// and the App Engine documentation for your runtime on [How Requests are
    /// Handled](https://cloud.google.com/appengine/docs/standard/python3/how-requests-are-handled).
    pub http_method: crate::model::HttpMethod,

    /// Task-level setting for App Engine routing.
    ///
    /// * If [app_engine_routing_override is set on the
    ///   queue][google.cloud.tasks.v2.Queue.app_engine_routing_override], this
    ///   value is used for all tasks in the queue, no matter what the setting is
    ///   for the [task-level
    ///   app_engine_routing][google.cloud.tasks.v2.AppEngineHttpRequest.app_engine_routing].
    ///
    /// [google.cloud.tasks.v2.AppEngineHttpRequest.app_engine_routing]: crate::model::AppEngineHttpRequest::app_engine_routing
    /// [google.cloud.tasks.v2.Queue.app_engine_routing_override]: crate::model::Queue::app_engine_routing_override
    pub app_engine_routing: std::option::Option<crate::model::AppEngineRouting>,

    /// The relative URI.
    ///
    /// The relative URI must begin with "/" and must be a valid HTTP relative URI.
    /// It can contain a path and query string arguments.
    /// If the relative URI is empty, then the root path "/" will be used.
    /// No spaces are allowed, and the maximum length allowed is 2083 characters.
    pub relative_uri: std::string::String,

    /// HTTP request headers.
    ///
    /// This map contains the header field names and values.
    /// Headers can be set when the
    /// [task is created][google.cloud.tasks.v2.CloudTasks.CreateTask].
    /// Repeated headers are not supported but a header value can contain commas.
    ///
    /// Cloud Tasks sets some headers to default values:
    ///
    /// * `User-Agent`: By default, this header is
    ///   `"AppEngine-Google; (+<http://code.google.com/appengine>)"`.
    ///   This header can be modified, but Cloud Tasks will append
    ///   `"AppEngine-Google; (+<http://code.google.com/appengine>)"` to the
    ///   modified `User-Agent`.
    ///
    /// If the task has a [body][google.cloud.tasks.v2.AppEngineHttpRequest.body],
    /// Cloud Tasks sets the following headers:
    ///
    /// * `Content-Type`: By default, the `Content-Type` header is set to
    ///   `"application/octet-stream"`. The default can be overridden by explicitly
    ///   setting `Content-Type` to a particular media type when the
    ///   [task is created][google.cloud.tasks.v2.CloudTasks.CreateTask].
    ///   For example, `Content-Type` can be set to `"application/json"`.
    /// * `Content-Length`: This is computed by Cloud Tasks. This value is
    ///   output only.   It cannot be changed.
    ///
    /// The headers below cannot be set or overridden:
    ///
    /// * `Host`
    /// * `X-Google-*`
    /// * `X-AppEngine-*`
    ///
    /// In addition, Cloud Tasks sets some headers when the task is dispatched,
    /// such as headers containing information about the task; see
    /// [request
    /// headers](https://cloud.google.com/tasks/docs/creating-appengine-handlers#reading_request_headers).
    /// These headers are set only when the task is dispatched, so they are not
    /// visible when the task is returned in a Cloud Tasks response.
    ///
    /// Although there is no specific limit for the maximum number of headers or
    /// the size, there is a limit on the maximum size of the
    /// [Task][google.cloud.tasks.v2.Task]. For more information, see the
    /// [CreateTask][google.cloud.tasks.v2.CloudTasks.CreateTask] documentation.
    ///
    /// [google.cloud.tasks.v2.AppEngineHttpRequest.body]: crate::model::AppEngineHttpRequest::body
    /// [google.cloud.tasks.v2.CloudTasks.CreateTask]: crate::client::CloudTasks::create_task
    /// [google.cloud.tasks.v2.Task]: crate::model::Task
    pub headers: std::collections::HashMap<std::string::String, std::string::String>,

    /// HTTP request body.
    ///
    /// A request body is allowed only if the HTTP method is POST or PUT. It is
    /// an error to set a body on a task with an incompatible
    /// [HttpMethod][google.cloud.tasks.v2.HttpMethod].
    ///
    /// [google.cloud.tasks.v2.HttpMethod]: crate::model::HttpMethod
    pub body: ::bytes::Bytes,

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

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

    /// Sets the value of [http_method][crate::model::AppEngineHttpRequest::http_method].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::AppEngineHttpRequest;
    /// use google_cloud_tasks_v2::model::HttpMethod;
    /// let x0 = AppEngineHttpRequest::new().set_http_method(HttpMethod::Post);
    /// let x1 = AppEngineHttpRequest::new().set_http_method(HttpMethod::Get);
    /// let x2 = AppEngineHttpRequest::new().set_http_method(HttpMethod::Head);
    /// ```
    pub fn set_http_method<T: std::convert::Into<crate::model::HttpMethod>>(
        mut self,
        v: T,
    ) -> Self {
        self.http_method = v.into();
        self
    }

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

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

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

    /// Sets the value of [headers][crate::model::AppEngineHttpRequest::headers].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::AppEngineHttpRequest;
    /// let x = AppEngineHttpRequest::new().set_headers([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_headers<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.headers = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

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

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

/// App Engine Routing.
///
/// Defines routing characteristics specific to App Engine - service, version,
/// and instance.
///
/// For more information about services, versions, and instances see
/// [An Overview of App
/// Engine](https://cloud.google.com/appengine/docs/python/an-overview-of-app-engine),
/// [Microservices Architecture on Google App
/// Engine](https://cloud.google.com/appengine/docs/python/microservices-on-app-engine),
/// [App Engine Standard request
/// routing](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed),
/// and [App Engine Flex request
/// routing](https://cloud.google.com/appengine/docs/flexible/python/how-requests-are-routed).
///
/// Using [AppEngineRouting][google.cloud.tasks.v2.AppEngineRouting] requires
/// [`appengine.applications.get`](https://cloud.google.com/appengine/docs/admin-api/access-control)
/// Google IAM permission for the project
/// and the following scope:
///
/// `<https://www.googleapis.com/auth/cloud-platform>`
///
/// [google.cloud.tasks.v2.AppEngineRouting]: crate::model::AppEngineRouting
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AppEngineRouting {
    /// App service.
    ///
    /// By default, the task is sent to the service which is the default
    /// service when the task is attempted.
    ///
    /// For some queues or tasks which were created using the App Engine
    /// Task Queue API, [host][google.cloud.tasks.v2.AppEngineRouting.host] is not
    /// parsable into [service][google.cloud.tasks.v2.AppEngineRouting.service],
    /// [version][google.cloud.tasks.v2.AppEngineRouting.version], and
    /// [instance][google.cloud.tasks.v2.AppEngineRouting.instance]. For example,
    /// some tasks which were created using the App Engine SDK use a custom domain
    /// name; custom domains are not parsed by Cloud Tasks. If
    /// [host][google.cloud.tasks.v2.AppEngineRouting.host] is not parsable, then
    /// [service][google.cloud.tasks.v2.AppEngineRouting.service],
    /// [version][google.cloud.tasks.v2.AppEngineRouting.version], and
    /// [instance][google.cloud.tasks.v2.AppEngineRouting.instance] are the empty
    /// string.
    ///
    /// [google.cloud.tasks.v2.AppEngineRouting.host]: crate::model::AppEngineRouting::host
    /// [google.cloud.tasks.v2.AppEngineRouting.instance]: crate::model::AppEngineRouting::instance
    /// [google.cloud.tasks.v2.AppEngineRouting.service]: crate::model::AppEngineRouting::service
    /// [google.cloud.tasks.v2.AppEngineRouting.version]: crate::model::AppEngineRouting::version
    pub service: std::string::String,

    /// App version.
    ///
    /// By default, the task is sent to the version which is the default
    /// version when the task is attempted.
    ///
    /// For some queues or tasks which were created using the App Engine
    /// Task Queue API, [host][google.cloud.tasks.v2.AppEngineRouting.host] is not
    /// parsable into [service][google.cloud.tasks.v2.AppEngineRouting.service],
    /// [version][google.cloud.tasks.v2.AppEngineRouting.version], and
    /// [instance][google.cloud.tasks.v2.AppEngineRouting.instance]. For example,
    /// some tasks which were created using the App Engine SDK use a custom domain
    /// name; custom domains are not parsed by Cloud Tasks. If
    /// [host][google.cloud.tasks.v2.AppEngineRouting.host] is not parsable, then
    /// [service][google.cloud.tasks.v2.AppEngineRouting.service],
    /// [version][google.cloud.tasks.v2.AppEngineRouting.version], and
    /// [instance][google.cloud.tasks.v2.AppEngineRouting.instance] are the empty
    /// string.
    ///
    /// [google.cloud.tasks.v2.AppEngineRouting.host]: crate::model::AppEngineRouting::host
    /// [google.cloud.tasks.v2.AppEngineRouting.instance]: crate::model::AppEngineRouting::instance
    /// [google.cloud.tasks.v2.AppEngineRouting.service]: crate::model::AppEngineRouting::service
    /// [google.cloud.tasks.v2.AppEngineRouting.version]: crate::model::AppEngineRouting::version
    pub version: std::string::String,

    /// App instance.
    ///
    /// By default, the task is sent to an instance which is available when
    /// the task is attempted.
    ///
    /// Requests can only be sent to a specific instance if
    /// [manual scaling is used in App Engine
    /// Standard](https://cloud.google.com/appengine/docs/python/an-overview-of-app-engine?hl=en_US#scaling_types_and_instance_classes).
    /// App Engine Flex does not support instances. For more information, see
    /// [App Engine Standard request
    /// routing](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed)
    /// and [App Engine Flex request
    /// routing](https://cloud.google.com/appengine/docs/flexible/python/how-requests-are-routed).
    pub instance: std::string::String,

    /// Output only. The host that the task is sent to.
    ///
    /// The host is constructed from the domain name of the app associated with
    /// the queue's project ID (for example \<app-id\>.appspot.com), and the
    /// [service][google.cloud.tasks.v2.AppEngineRouting.service],
    /// [version][google.cloud.tasks.v2.AppEngineRouting.version], and
    /// [instance][google.cloud.tasks.v2.AppEngineRouting.instance]. Tasks which
    /// were created using the App Engine SDK might have a custom domain name.
    ///
    /// For more information, see
    /// [How Requests are
    /// Routed](https://cloud.google.com/appengine/docs/standard/python/how-requests-are-routed).
    ///
    /// [google.cloud.tasks.v2.AppEngineRouting.instance]: crate::model::AppEngineRouting::instance
    /// [google.cloud.tasks.v2.AppEngineRouting.service]: crate::model::AppEngineRouting::service
    /// [google.cloud.tasks.v2.AppEngineRouting.version]: crate::model::AppEngineRouting::version
    pub host: std::string::String,

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

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

    /// Sets the value of [service][crate::model::AppEngineRouting::service].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::AppEngineRouting;
    /// let x = AppEngineRouting::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 [version][crate::model::AppEngineRouting::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::AppEngineRouting;
    /// let x = AppEngineRouting::new().set_version("example");
    /// ```
    pub fn set_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.version = v.into();
        self
    }

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

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

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

/// Contains information needed for generating an
/// [OAuth token](https://developers.google.com/identity/protocols/OAuth2).
/// This type of authorization should generally only be used when calling Google
/// APIs hosted on *.googleapis.com.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OAuthToken {
    /// [Service account email](https://cloud.google.com/iam/docs/service-accounts)
    /// to be used for generating OAuth token.
    /// The service account must be within the same project as the queue. The
    /// caller must have iam.serviceAccounts.actAs permission for the service
    /// account.
    pub service_account_email: std::string::String,

    /// OAuth scope to be used for generating OAuth access token.
    /// If not specified, `https://www.googleapis.com/auth/cloud-platform`
    /// will be used.
    pub scope: std::string::String,

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

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

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

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

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

/// Contains information needed for generating an
/// [OpenID Connect
/// token](https://developers.google.com/identity/protocols/OpenIDConnect).
/// This type of authorization can be used for many scenarios, including
/// calling Cloud Run, or endpoints where you intend to validate the token
/// yourself.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OidcToken {
    /// [Service account email](https://cloud.google.com/iam/docs/service-accounts)
    /// to be used for generating OIDC token.
    /// The service account must be within the same project as the queue. The
    /// caller must have iam.serviceAccounts.actAs permission for the service
    /// account.
    pub service_account_email: std::string::String,

    /// Audience to be used when generating OIDC token. If not specified, the URI
    /// specified in target will be used.
    pub audience: std::string::String,

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

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

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

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

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

/// A unit of scheduled work.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Task {
    /// Optionally caller-specified in
    /// [CreateTask][google.cloud.tasks.v2.CloudTasks.CreateTask].
    ///
    /// The task name.
    ///
    /// The task name must have the following format:
    /// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID`
    ///
    /// * `PROJECT_ID` can contain letters ([A-Za-z]), numbers ([0-9]),
    ///   hyphens (-), colons (:), or periods (.).
    ///   For more information, see
    ///   [Identifying
    ///   projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects#identifying_projects)
    /// * `LOCATION_ID` is the canonical ID for the task's location.
    ///   The list of available locations can be obtained by calling
    ///   [ListLocations][google.cloud.location.Locations.ListLocations].
    ///   For more information, see <https://cloud.google.com/about/locations/>.
    /// * `QUEUE_ID` can contain letters ([A-Za-z]), numbers ([0-9]), or
    ///   hyphens (-). The maximum length is 100 characters.
    /// * `TASK_ID` can contain only letters ([A-Za-z]), numbers ([0-9]),
    ///   hyphens (-), or underscores (_). The maximum length is 500 characters.
    ///
    /// [google.cloud.tasks.v2.CloudTasks.CreateTask]: crate::client::CloudTasks::create_task
    pub name: std::string::String,

    /// The time when the task is scheduled to be attempted or retried.
    ///
    /// `schedule_time` will be truncated to the nearest microsecond.
    pub schedule_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time that the task was created.
    ///
    /// `create_time` will be truncated to the nearest second.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// The deadline for requests sent to the worker. If the worker does not
    /// respond by this deadline then the request is cancelled and the attempt
    /// is marked as a `DEADLINE_EXCEEDED` failure. Cloud Tasks will retry the
    /// task according to the [RetryConfig][google.cloud.tasks.v2.RetryConfig].
    ///
    /// Note that when the request is cancelled, Cloud Tasks will stop listening
    /// for the response, but whether the worker stops processing depends on the
    /// worker. For example, if the worker is stuck, it may not react to cancelled
    /// requests.
    ///
    /// The default and maximum values depend on the type of request:
    ///
    /// * For [HTTP tasks][google.cloud.tasks.v2.HttpRequest], the default is 10
    ///   minutes. The deadline
    ///   must be in the interval [15 seconds, 30 minutes].
    ///
    /// * For [App Engine tasks][google.cloud.tasks.v2.AppEngineHttpRequest], 0
    ///   indicates that the
    ///   request has the default deadline. The default deadline depends on the
    ///   [scaling
    ///   type](https://cloud.google.com/appengine/docs/standard/go/how-instances-are-managed#instance_scaling)
    ///   of the service: 10 minutes for standard apps with automatic scaling, 24
    ///   hours for standard apps with manual and basic scaling, and 60 minutes for
    ///   flex apps. If the request deadline is set, it must be in the interval [15
    ///   seconds, 24 hours 15 seconds]. Regardless of the task's
    ///   `dispatch_deadline`, the app handler will not run for longer than than
    ///   the service's timeout. We recommend setting the `dispatch_deadline` to
    ///   at most a few seconds more than the app handler's timeout. For more
    ///   information see
    ///   [Timeouts](https://cloud.google.com/tasks/docs/creating-appengine-handlers#timeouts).
    ///
    ///
    /// The value must be given as a string that indicates the length of time
    /// (in seconds) followed by `s` (for "seconds"). For more information on the
    /// format, see the documentation for
    /// [Duration](https://protobuf.dev/reference/protobuf/google.protobuf/#duration).
    /// `dispatch_deadline` will be truncated to the nearest millisecond. The
    /// deadline is an approximate deadline.
    ///
    /// [google.cloud.tasks.v2.AppEngineHttpRequest]: crate::model::AppEngineHttpRequest
    /// [google.cloud.tasks.v2.HttpRequest]: crate::model::HttpRequest
    /// [google.cloud.tasks.v2.RetryConfig]: crate::model::RetryConfig
    pub dispatch_deadline: std::option::Option<wkt::Duration>,

    /// Output only. The number of attempts dispatched.
    ///
    /// This count includes attempts which have been dispatched but haven't
    /// received a response.
    pub dispatch_count: i32,

    /// Output only. The number of attempts which have received a response.
    pub response_count: i32,

    /// Output only. The status of the task's first attempt.
    ///
    /// Only [dispatch_time][google.cloud.tasks.v2.Attempt.dispatch_time] will be
    /// set. The other [Attempt][google.cloud.tasks.v2.Attempt] information is not
    /// retained by Cloud Tasks.
    ///
    /// [google.cloud.tasks.v2.Attempt]: crate::model::Attempt
    /// [google.cloud.tasks.v2.Attempt.dispatch_time]: crate::model::Attempt::dispatch_time
    pub first_attempt: std::option::Option<crate::model::Attempt>,

    /// Output only. The status of the task's last attempt.
    pub last_attempt: std::option::Option<crate::model::Attempt>,

    /// Output only. The view specifies which subset of the
    /// [Task][google.cloud.tasks.v2.Task] has been returned.
    ///
    /// [google.cloud.tasks.v2.Task]: crate::model::Task
    pub view: crate::model::task::View,

    /// Optional. Specifies the task-level
    /// [RetryConfig][google.cloud.tasks.v2.RetryConfig].
    ///
    /// If present, this overrides the
    /// [Queue.retry_config][google.cloud.tasks.v2.Queue.retry_config] for this
    /// task.
    ///
    /// [google.cloud.tasks.v2.Queue.retry_config]: crate::model::Queue::retry_config
    /// [google.cloud.tasks.v2.RetryConfig]: crate::model::RetryConfig
    pub retry_config: std::option::Option<crate::model::RetryConfig>,

    /// Required. The message to send to the worker.
    pub message_type: std::option::Option<crate::model::task::MessageType>,

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

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

    /// Sets the value of [name][crate::model::Task::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::Task;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let queue_id = "queue_id";
    /// # let task_id = "task_id";
    /// let x = Task::new().set_name(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}/tasks/{task_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 [schedule_time][crate::model::Task::schedule_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::Task;
    /// use wkt::Timestamp;
    /// let x = Task::new().set_schedule_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_schedule_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.schedule_time = std::option::Option::Some(v.into());
        self
    }

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

    /// Sets the value of [create_time][crate::model::Task::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::Task;
    /// use wkt::Timestamp;
    /// let x = Task::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::Task::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::Task;
    /// use wkt::Timestamp;
    /// let x = Task::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = Task::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 [dispatch_deadline][crate::model::Task::dispatch_deadline].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::Task;
    /// use wkt::Duration;
    /// let x = Task::new().set_dispatch_deadline(Duration::default()/* use setters */);
    /// ```
    pub fn set_dispatch_deadline<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.dispatch_deadline = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

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

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

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

    /// Sets the value of [view][crate::model::Task::view].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::Task;
    /// use google_cloud_tasks_v2::model::task::View;
    /// let x0 = Task::new().set_view(View::Basic);
    /// let x1 = Task::new().set_view(View::Full);
    /// ```
    pub fn set_view<T: std::convert::Into<crate::model::task::View>>(mut self, v: T) -> Self {
        self.view = v.into();
        self
    }

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

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

    /// Sets the value of [message_type][crate::model::Task::message_type].
    ///
    /// Note that all the setters affecting `message_type` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::Task;
    /// use google_cloud_tasks_v2::model::AppEngineHttpRequest;
    /// let x = Task::new().set_message_type(Some(
    ///     google_cloud_tasks_v2::model::task::MessageType::AppEngineHttpRequest(AppEngineHttpRequest::default().into())));
    /// ```
    pub fn set_message_type<
        T: std::convert::Into<std::option::Option<crate::model::task::MessageType>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.message_type = v.into();
        self
    }

    /// The value of [message_type][crate::model::Task::message_type]
    /// if it holds a `AppEngineHttpRequest`, `None` if the field is not set or
    /// holds a different branch.
    pub fn app_engine_http_request(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::AppEngineHttpRequest>> {
        #[allow(unreachable_patterns)]
        self.message_type.as_ref().and_then(|v| match v {
            crate::model::task::MessageType::AppEngineHttpRequest(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [message_type][crate::model::Task::message_type]
    /// to hold a `AppEngineHttpRequest`.
    ///
    /// Note that all the setters affecting `message_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::Task;
    /// use google_cloud_tasks_v2::model::AppEngineHttpRequest;
    /// let x = Task::new().set_app_engine_http_request(AppEngineHttpRequest::default()/* use setters */);
    /// assert!(x.app_engine_http_request().is_some());
    /// assert!(x.http_request().is_none());
    /// ```
    pub fn set_app_engine_http_request<
        T: std::convert::Into<std::boxed::Box<crate::model::AppEngineHttpRequest>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.message_type = std::option::Option::Some(
            crate::model::task::MessageType::AppEngineHttpRequest(v.into()),
        );
        self
    }

    /// The value of [message_type][crate::model::Task::message_type]
    /// if it holds a `HttpRequest`, `None` if the field is not set or
    /// holds a different branch.
    pub fn http_request(&self) -> std::option::Option<&std::boxed::Box<crate::model::HttpRequest>> {
        #[allow(unreachable_patterns)]
        self.message_type.as_ref().and_then(|v| match v {
            crate::model::task::MessageType::HttpRequest(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [message_type][crate::model::Task::message_type]
    /// to hold a `HttpRequest`.
    ///
    /// Note that all the setters affecting `message_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_tasks_v2::model::Task;
    /// use google_cloud_tasks_v2::model::HttpRequest;
    /// let x = Task::new().set_http_request(HttpRequest::default()/* use setters */);
    /// assert!(x.http_request().is_some());
    /// assert!(x.app_engine_http_request().is_none());
    /// ```
    pub fn set_http_request<T: std::convert::Into<std::boxed::Box<crate::model::HttpRequest>>>(
        mut self,
        v: T,
    ) -> Self {
        self.message_type =
            std::option::Option::Some(crate::model::task::MessageType::HttpRequest(v.into()));
        self
    }
}

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

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

    /// The view specifies a subset of [Task][google.cloud.tasks.v2.Task] data.
    ///
    /// When a task is returned in a response, not all
    /// information is retrieved by default because some data, such as
    /// payloads, might be desirable to return only when needed because
    /// of its large size or because of the sensitivity of data that it
    /// contains.
    ///
    /// [google.cloud.tasks.v2.Task]: crate::model::Task
    ///
    /// # 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 View {
        /// Unspecified. Defaults to BASIC.
        Unspecified,
        /// The basic view omits fields which can be large or can contain
        /// sensitive data.
        ///
        /// This view does not include the
        /// [body in
        /// AppEngineHttpRequest][google.cloud.tasks.v2.AppEngineHttpRequest.body].
        /// Bodies are desirable to return only when needed, because they
        /// can be large and because of the sensitivity of the data that you
        /// choose to store in it.
        ///
        /// [google.cloud.tasks.v2.AppEngineHttpRequest.body]: crate::model::AppEngineHttpRequest::body
        Basic,
        /// All information is returned.
        ///
        /// Authorization for [FULL][google.cloud.tasks.v2.Task.View.FULL] requires
        /// `cloudtasks.tasks.fullView` [Google IAM](https://cloud.google.com/iam/)
        /// permission on the [Queue][google.cloud.tasks.v2.Queue] resource.
        ///
        /// [google.cloud.tasks.v2.Queue]: crate::model::Queue
        /// [google.cloud.tasks.v2.Task.View.FULL]: crate::model::task::View::Full
        Full,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [View::value] or
        /// [View::name].
        UnknownValue(view::UnknownValue),
    }

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

    impl View {
        /// 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::Basic => std::option::Option::Some(1),
                Self::Full => 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("VIEW_UNSPECIFIED"),
                Self::Basic => std::option::Option::Some("BASIC"),
                Self::Full => std::option::Option::Some("FULL"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

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

    impl std::convert::From<&str> for View {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "VIEW_UNSPECIFIED" => Self::Unspecified,
                "BASIC" => Self::Basic,
                "FULL" => Self::Full,
                _ => Self::UnknownValue(view::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

    /// Required. The message to send to the worker.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum MessageType {
        /// HTTP request that is sent to the App Engine app handler.
        ///
        /// An App Engine task is a task that has
        /// [AppEngineHttpRequest][google.cloud.tasks.v2.AppEngineHttpRequest] set.
        ///
        /// [google.cloud.tasks.v2.AppEngineHttpRequest]: crate::model::AppEngineHttpRequest
        AppEngineHttpRequest(std::boxed::Box<crate::model::AppEngineHttpRequest>),
        /// HTTP request that is sent to the worker.
        ///
        /// An HTTP task is a task that has
        /// [HttpRequest][google.cloud.tasks.v2.HttpRequest] set.
        ///
        /// [google.cloud.tasks.v2.HttpRequest]: crate::model::HttpRequest
        HttpRequest(std::boxed::Box<crate::model::HttpRequest>),
    }
}

/// The status of a task attempt.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Attempt {
    /// Output only. The time that this attempt was scheduled.
    ///
    /// `schedule_time` will be truncated to the nearest microsecond.
    pub schedule_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time that this attempt was dispatched.
    ///
    /// `dispatch_time` will be truncated to the nearest microsecond.
    pub dispatch_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time that this attempt response was received.
    ///
    /// `response_time` will be truncated to the nearest microsecond.
    pub response_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The response from the worker for this attempt.
    ///
    /// If `response_time` is unset, then the task has not been attempted or is
    /// currently running and the `response_status` field is meaningless.
    pub response_status: std::option::Option<google_cloud_rpc::model::Status>,

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

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

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

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

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

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

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

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

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

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

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

/// The HTTP method used to deliver the task.
///
/// # 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 HttpMethod {
    /// HTTP method unspecified
    Unspecified,
    /// HTTP POST
    Post,
    /// HTTP GET
    Get,
    /// HTTP HEAD
    Head,
    /// HTTP PUT
    Put,
    /// HTTP DELETE
    Delete,
    /// HTTP PATCH
    Patch,
    /// HTTP OPTIONS
    Options,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [HttpMethod::value] or
    /// [HttpMethod::name].
    UnknownValue(http_method::UnknownValue),
}

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

impl HttpMethod {
    /// 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::Post => std::option::Option::Some(1),
            Self::Get => std::option::Option::Some(2),
            Self::Head => std::option::Option::Some(3),
            Self::Put => std::option::Option::Some(4),
            Self::Delete => std::option::Option::Some(5),
            Self::Patch => std::option::Option::Some(6),
            Self::Options => std::option::Option::Some(7),
            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("HTTP_METHOD_UNSPECIFIED"),
            Self::Post => std::option::Option::Some("POST"),
            Self::Get => std::option::Option::Some("GET"),
            Self::Head => std::option::Option::Some("HEAD"),
            Self::Put => std::option::Option::Some("PUT"),
            Self::Delete => std::option::Option::Some("DELETE"),
            Self::Patch => std::option::Option::Some("PATCH"),
            Self::Options => std::option::Option::Some("OPTIONS"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

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

impl std::fmt::Display for HttpMethod {
    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 HttpMethod {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::Post,
            2 => Self::Get,
            3 => Self::Head,
            4 => Self::Put,
            5 => Self::Delete,
            6 => Self::Patch,
            7 => Self::Options,
            _ => Self::UnknownValue(http_method::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for HttpMethod {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "HTTP_METHOD_UNSPECIFIED" => Self::Unspecified,
            "POST" => Self::Post,
            "GET" => Self::Get,
            "HEAD" => Self::Head,
            "PUT" => Self::Put,
            "DELETE" => Self::Delete,
            "PATCH" => Self::Patch,
            "OPTIONS" => Self::Options,
            _ => Self::UnknownValue(http_method::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for HttpMethod {
    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::Post => serializer.serialize_i32(1),
            Self::Get => serializer.serialize_i32(2),
            Self::Head => serializer.serialize_i32(3),
            Self::Put => serializer.serialize_i32(4),
            Self::Delete => serializer.serialize_i32(5),
            Self::Patch => serializer.serialize_i32(6),
            Self::Options => serializer.serialize_i32(7),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

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