google_cloud_tasks_v2/

client.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)]

/// Implements a client for the Cloud Tasks API.
///
/// # Example
/// ```
/// # use google_cloud_tasks_v2::client::CloudTasks;
/// use google_cloud_gax::paginator::ItemPaginator as _;
/// async fn sample(
///    project_id: &str,
///    location_id: &str,
/// ) -> anyhow::Result<()> {
///     let client = CloudTasks::builder().build().await?;
///     let mut list = client.list_queues()
///         .set_parent(format!("projects/{project_id}/locations/{location_id}"))
///         .by_item();
///     while let Some(item) = list.next().await.transpose()? {
///         println!("{:?}", item);
///     }
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// Cloud Tasks allows developers to manage the execution of background
/// work in their applications.
///
/// # Configuration
///
/// To configure `CloudTasks` use the `with_*` methods in the type returned
/// by [builder()][CloudTasks::builder]. The default configuration should
/// work for most applications. Common configuration changes include
///
/// * [with_endpoint()]: by default this client uses the global default endpoint
///   (`https://cloudtasks.googleapis.com`). Applications using regional
///   endpoints or running in restricted networks (e.g. a network configured
///   with [Private Google Access with VPC Service Controls]) may want to
///   override this default.
/// * [with_credentials()]: by default this client uses
///   [Application Default Credentials]. Applications using custom
///   authentication may need to override this default.
///
/// [with_endpoint()]: super::builder::cloud_tasks::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::cloud_tasks::ClientBuilder::with_credentials
/// [Private Google Access with VPC Service Controls]: https://cloud.google.com/vpc-service-controls/docs/private-connectivity
/// [Application Default Credentials]: https://cloud.google.com/docs/authentication#adc
///
/// # Pooling and Cloning
///
/// `CloudTasks` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `CloudTasks` in
/// an [Rc](std::rc::Rc) or [Arc](std::sync::Arc) to reuse it, because it
/// already uses an `Arc` internally.
#[derive(Clone, Debug)]
pub struct CloudTasks {
    inner: std::sync::Arc<dyn super::stub::dynamic::CloudTasks>,
}

impl CloudTasks {
    /// Returns a builder for [CloudTasks].
    ///
    /// ```
    /// # async fn sample() -> google_cloud_gax::client_builder::Result<()> {
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// let client = CloudTasks::builder().build().await?;
    /// # Ok(()) }
    /// ```
    pub fn builder() -> super::builder::cloud_tasks::ClientBuilder {
        crate::new_client_builder(super::builder::cloud_tasks::client::Factory)
    }

    /// Creates a new client from the provided stub.
    ///
    /// The most common case for calling this function is in tests mocking the
    /// client's behavior.
    pub fn from_stub<T>(stub: impl Into<std::sync::Arc<T>>) -> Self
    where
        T: super::stub::CloudTasks + 'static,
    {
        Self { inner: stub.into() }
    }

    pub(crate) async fn new(
        config: gaxi::options::ClientConfig,
    ) -> crate::ClientBuilderResult<Self> {
        let inner = Self::build_inner(config).await?;
        Ok(Self { inner })
    }

    async fn build_inner(
        conf: gaxi::options::ClientConfig,
    ) -> crate::ClientBuilderResult<std::sync::Arc<dyn super::stub::dynamic::CloudTasks>> {
        if gaxi::options::tracing_enabled(&conf) {
            return Ok(std::sync::Arc::new(Self::build_with_tracing(conf).await?));
        }
        Ok(std::sync::Arc::new(Self::build_transport(conf).await?))
    }

    async fn build_transport(
        conf: gaxi::options::ClientConfig,
    ) -> crate::ClientBuilderResult<impl super::stub::CloudTasks> {
        super::transport::CloudTasks::new(conf).await
    }

    async fn build_with_tracing(
        conf: gaxi::options::ClientConfig,
    ) -> crate::ClientBuilderResult<impl super::stub::CloudTasks> {
        Self::build_transport(conf)
            .await
            .map(super::tracing::CloudTasks::new)
    }

    /// Lists queues.
    ///
    /// Queues are returned in lexicographical order.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks, project_id: &str, location_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_queues()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_queues(&self) -> super::builder::cloud_tasks::ListQueues {
        super::builder::cloud_tasks::ListQueues::new(self.inner.clone())
    }

    /// Gets a queue.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks, project_id: &str, location_id: &str, queue_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_queue()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_queue(&self) -> super::builder::cloud_tasks::GetQueue {
        super::builder::cloud_tasks::GetQueue::new(self.inner.clone())
    }

    /// Creates a queue.
    ///
    /// Queues created with this method allow tasks to live for a maximum of 31
    /// days. After a task is 31 days old, the task will be deleted regardless of
    /// whether it was dispatched or not.
    ///
    /// WARNING: Using this method may have unintended side effects if you are
    /// using an App Engine `queue.yaml` or `queue.xml` file to manage your queues.
    /// Read
    /// [Overview of Queue Management and
    /// queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using
    /// this method.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::model::Queue;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks, project_id: &str, location_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_queue()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}"))
    ///         .set_queue(
    ///             Queue::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_queue(&self) -> super::builder::cloud_tasks::CreateQueue {
        super::builder::cloud_tasks::CreateQueue::new(self.inner.clone())
    }

    /// Updates a queue.
    ///
    /// This method creates the queue if it does not exist and updates
    /// the queue if it does exist.
    ///
    /// Queues created with this method allow tasks to live for a maximum of 31
    /// days. After a task is 31 days old, the task will be deleted regardless of
    /// whether it was dispatched or not.
    ///
    /// WARNING: Using this method may have unintended side effects if you are
    /// using an App Engine `queue.yaml` or `queue.xml` file to manage your queues.
    /// Read
    /// [Overview of Queue Management and
    /// queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using
    /// this method.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_tasks_v2::model::Queue;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks, project_id: &str, location_id: &str, queue_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_queue()
    ///         .set_queue(
    ///             Queue::new().set_name(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_queue(&self) -> super::builder::cloud_tasks::UpdateQueue {
        super::builder::cloud_tasks::UpdateQueue::new(self.inner.clone())
    }

    /// Deletes a queue.
    ///
    /// This command will delete the queue even if it has tasks in it.
    ///
    /// Note: If you delete a queue, you may be prevented from creating a new queue
    /// with the same name as the deleted queue for a tombstone window of up to
    /// 3 days. During this window, the CreateQueue operation may appear to
    /// recreate the queue, but this can be misleading. If you attempt to create
    /// a queue with the same name as one that is in the tombstone window, run
    /// GetQueue to confirm that the queue creation was successful. If GetQueue
    /// returns 200 response code, your queue was successfully created with the
    /// name of the previously deleted queue. Otherwise, your queue did not
    /// successfully recreate.
    ///
    /// WARNING: Using this method may have unintended side effects if you are
    /// using an App Engine `queue.yaml` or `queue.xml` file to manage your queues.
    /// Read
    /// [Overview of Queue Management and
    /// queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using
    /// this method.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks, project_id: &str, location_id: &str, queue_id: &str
    /// ) -> Result<()> {
    ///     client.delete_queue()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_queue(&self) -> super::builder::cloud_tasks::DeleteQueue {
        super::builder::cloud_tasks::DeleteQueue::new(self.inner.clone())
    }

    /// Purges a queue by deleting all of its tasks.
    ///
    /// All tasks created before this method is called are permanently deleted.
    ///
    /// Purge operations can take up to one minute to take effect. Tasks
    /// might be dispatched before the purge takes effect. A purge is irreversible.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks
    /// ) -> Result<()> {
    ///     let response = client.purge_queue()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn purge_queue(&self) -> super::builder::cloud_tasks::PurgeQueue {
        super::builder::cloud_tasks::PurgeQueue::new(self.inner.clone())
    }

    /// Pauses the queue.
    ///
    /// If a queue is paused then the system will stop dispatching tasks
    /// until the queue is resumed via
    /// [ResumeQueue][google.cloud.tasks.v2.CloudTasks.ResumeQueue]. Tasks can
    /// still be added when the queue is paused. A queue is paused if its
    /// [state][google.cloud.tasks.v2.Queue.state] is
    /// [PAUSED][google.cloud.tasks.v2.Queue.State.PAUSED].
    ///
    /// [google.cloud.tasks.v2.CloudTasks.ResumeQueue]: crate::client::CloudTasks::resume_queue
    /// [google.cloud.tasks.v2.Queue.State.PAUSED]: crate::model::queue::State::Paused
    /// [google.cloud.tasks.v2.Queue.state]: crate::model::Queue::state
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks
    /// ) -> Result<()> {
    ///     let response = client.pause_queue()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn pause_queue(&self) -> super::builder::cloud_tasks::PauseQueue {
        super::builder::cloud_tasks::PauseQueue::new(self.inner.clone())
    }

    /// Resume a queue.
    ///
    /// This method resumes a queue after it has been
    /// [PAUSED][google.cloud.tasks.v2.Queue.State.PAUSED] or
    /// [DISABLED][google.cloud.tasks.v2.Queue.State.DISABLED]. The state of a
    /// queue is stored in the queue's [state][google.cloud.tasks.v2.Queue.state];
    /// after calling this method it will be set to
    /// [RUNNING][google.cloud.tasks.v2.Queue.State.RUNNING].
    ///
    /// WARNING: Resuming many high-QPS queues at the same time can
    /// lead to target overloading. If you are resuming high-QPS
    /// queues, follow the 500/50/5 pattern described in
    /// [Managing Cloud Tasks Scaling
    /// Risks](https://cloud.google.com/tasks/docs/manage-cloud-task-scaling).
    ///
    /// [google.cloud.tasks.v2.Queue.State.DISABLED]: crate::model::queue::State::Disabled
    /// [google.cloud.tasks.v2.Queue.State.PAUSED]: crate::model::queue::State::Paused
    /// [google.cloud.tasks.v2.Queue.State.RUNNING]: crate::model::queue::State::Running
    /// [google.cloud.tasks.v2.Queue.state]: crate::model::Queue::state
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks
    /// ) -> Result<()> {
    ///     let response = client.resume_queue()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn resume_queue(&self) -> super::builder::cloud_tasks::ResumeQueue {
        super::builder::cloud_tasks::ResumeQueue::new(self.inner.clone())
    }

    /// Gets the access control policy for a [Queue][google.cloud.tasks.v2.Queue].
    /// Returns an empty policy if the resource exists and does not have a policy
    /// set.
    ///
    /// Authorization requires the following
    /// [Google IAM](https://cloud.google.com/iam) permission on the specified
    /// resource parent:
    ///
    /// * `cloudtasks.queues.getIamPolicy`
    ///
    /// [google.cloud.tasks.v2.Queue]: crate::model::Queue
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks
    /// ) -> Result<()> {
    ///     let response = client.get_iam_policy()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_iam_policy(&self) -> super::builder::cloud_tasks::GetIamPolicy {
        super::builder::cloud_tasks::GetIamPolicy::new(self.inner.clone())
    }

    /// Sets the access control policy for a [Queue][google.cloud.tasks.v2.Queue].
    /// Replaces any existing policy.
    ///
    /// Note: The Cloud Console does not check queue-level IAM permissions yet.
    /// Project-level permissions are required to use the Cloud Console.
    ///
    /// Authorization requires the following
    /// [Google IAM](https://cloud.google.com/iam) permission on the specified
    /// resource parent:
    ///
    /// * `cloudtasks.queues.setIamPolicy`
    ///
    /// [google.cloud.tasks.v2.Queue]: crate::model::Queue
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks
    /// ) -> Result<()> {
    ///     let response = client.set_iam_policy()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn set_iam_policy(&self) -> super::builder::cloud_tasks::SetIamPolicy {
        super::builder::cloud_tasks::SetIamPolicy::new(self.inner.clone())
    }

    /// Returns permissions that a caller has on a
    /// [Queue][google.cloud.tasks.v2.Queue]. If the resource does not exist, this
    /// will return an empty set of permissions, not a
    /// [NOT_FOUND][google.rpc.Code.NOT_FOUND] error.
    ///
    /// Note: This operation is designed to be used for building permission-aware
    /// UIs and command-line tools, not for authorization checking. This operation
    /// may "fail open" without warning.
    ///
    /// [google.cloud.tasks.v2.Queue]: crate::model::Queue
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks
    /// ) -> Result<()> {
    ///     let response = client.test_iam_permissions()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn test_iam_permissions(&self) -> super::builder::cloud_tasks::TestIamPermissions {
        super::builder::cloud_tasks::TestIamPermissions::new(self.inner.clone())
    }

    /// Lists the tasks in a queue.
    ///
    /// By default, only the [BASIC][google.cloud.tasks.v2.Task.View.BASIC] view is
    /// retrieved due to performance considerations;
    /// [response_view][google.cloud.tasks.v2.ListTasksRequest.response_view]
    /// controls the subset of information which is returned.
    ///
    /// The tasks may be returned in any order. The ordering may change at any
    /// time.
    ///
    /// [google.cloud.tasks.v2.ListTasksRequest.response_view]: crate::model::ListTasksRequest::response_view
    /// [google.cloud.tasks.v2.Task.View.BASIC]: crate::model::task::View::Basic
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks, project_id: &str, location_id: &str, queue_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_tasks()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_tasks(&self) -> super::builder::cloud_tasks::ListTasks {
        super::builder::cloud_tasks::ListTasks::new(self.inner.clone())
    }

    /// Gets a task.
    ///
    /// After a task is successfully executed or has exhausted its retry attempts,
    /// the task is deleted. A `GetTask` request for a deleted task returns a
    /// `NOT_FOUND` error.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks, project_id: &str, location_id: &str, queue_id: &str, task_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_task()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}/tasks/{task_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_task(&self) -> super::builder::cloud_tasks::GetTask {
        super::builder::cloud_tasks::GetTask::new(self.inner.clone())
    }

    /// Creates a task and adds it to a queue.
    ///
    /// Tasks cannot be updated after creation; there is no UpdateTask command.
    ///
    /// * The maximum task size is 100KB.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::model::Task;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks, project_id: &str, location_id: &str, queue_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_task()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}"))
    ///         .set_task(
    ///             Task::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_task(&self) -> super::builder::cloud_tasks::CreateTask {
        super::builder::cloud_tasks::CreateTask::new(self.inner.clone())
    }

    /// Creates a batch of tasks and adds them to a queue.
    ///
    /// All tasks must be for the same queue.
    /// A maximum of 100 tasks can be created in a single batch.
    ///
    /// # Long running operations
    ///
    /// This method is used to start, and/or poll a [long-running Operation].
    /// The [Working with long-running operations] chapter in the [user guide]
    /// covers these operations in detail.
    ///
    /// [long-running operation]: https://google.aip.dev/151
    /// [user guide]: https://googleapis.github.io/google-cloud-rust/
    /// [working with long-running operations]: https://googleapis.github.io/google-cloud-rust/working_with_long_running_operations.html
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks
    /// ) -> Result<()> {
    ///     let response = client.batch_create_tasks()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn batch_create_tasks(&self) -> super::builder::cloud_tasks::BatchCreateTasks {
        super::builder::cloud_tasks::BatchCreateTasks::new(self.inner.clone())
    }

    /// Deletes a task.
    ///
    /// A task can be deleted if it is scheduled or dispatched. A task
    /// cannot be deleted if it has executed successfully or permanently
    /// failed.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks, project_id: &str, location_id: &str, queue_id: &str, task_id: &str
    /// ) -> Result<()> {
    ///     client.delete_task()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/queues/{queue_id}/tasks/{task_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_task(&self) -> super::builder::cloud_tasks::DeleteTask {
        super::builder::cloud_tasks::DeleteTask::new(self.inner.clone())
    }

    /// Deletes a batch of tasks.
    /// This is a non-atomic operation: if deletion fails for some tasks, it
    /// can still succeed for others. The metadata field of
    /// google.longrunning.Operation contains details of failed deletions.
    /// A maximum of 1000 tasks can be deleted in a batch.
    ///
    /// # Long running operations
    ///
    /// This method is used to start, and/or poll a [long-running Operation].
    /// The [Working with long-running operations] chapter in the [user guide]
    /// covers these operations in detail.
    ///
    /// [long-running operation]: https://google.aip.dev/151
    /// [user guide]: https://googleapis.github.io/google-cloud-rust/
    /// [working with long-running operations]: https://googleapis.github.io/google-cloud-rust/working_with_long_running_operations.html
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks
    /// ) -> Result<()> {
    ///     client.batch_delete_tasks()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn batch_delete_tasks(&self) -> super::builder::cloud_tasks::BatchDeleteTasks {
        super::builder::cloud_tasks::BatchDeleteTasks::new(self.inner.clone())
    }

    /// Forces a task to run now.
    ///
    /// When this method is called, Cloud Tasks will dispatch the task, even if
    /// the task is already running, the queue has reached its
    /// [RateLimits][google.cloud.tasks.v2.RateLimits] or is
    /// [PAUSED][google.cloud.tasks.v2.Queue.State.PAUSED].
    ///
    /// This command is meant to be used for manual debugging. For
    /// example, [RunTask][google.cloud.tasks.v2.CloudTasks.RunTask] can be used to
    /// retry a failed task after a fix has been made or to manually force a task
    /// to be dispatched now.
    ///
    /// If Cloud Tasks receives a successful response from the task's
    /// target, then the task will be deleted; otherwise the task's
    /// [schedule_time][google.cloud.tasks.v2.Task.schedule_time] will be reset to
    /// the time that [RunTask][google.cloud.tasks.v2.CloudTasks.RunTask] was
    /// called plus the retry delay specified in the queue's
    /// [RetryConfig][google.cloud.tasks.v2.RetryConfig].
    ///
    /// [RunTask][google.cloud.tasks.v2.CloudTasks.RunTask] returns
    /// [NOT_FOUND][google.rpc.Code.NOT_FOUND] when it is called on a
    /// task that has already succeeded or permanently failed.
    ///
    /// [google.cloud.tasks.v2.CloudTasks.RunTask]: crate::client::CloudTasks::run_task
    /// [google.cloud.tasks.v2.Queue.State.PAUSED]: crate::model::queue::State::Paused
    /// [google.cloud.tasks.v2.RateLimits]: crate::model::RateLimits
    /// [google.cloud.tasks.v2.RetryConfig]: crate::model::RetryConfig
    /// [google.cloud.tasks.v2.Task.schedule_time]: crate::model::Task::schedule_time
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks
    /// ) -> Result<()> {
    ///     let response = client.run_task()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn run_task(&self) -> super::builder::cloud_tasks::RunTask {
        super::builder::cloud_tasks::RunTask::new(self.inner.clone())
    }

    /// Creates or Updates a CMEK config.
    ///
    /// Updates the Customer Managed Encryption Key associated with the Cloud Tasks
    /// location (Creates if the key does not already exist). All new tasks created
    /// in the location will be encrypted at-rest with the KMS-key provided in the
    /// config.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_tasks_v2::model::CmekConfig;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks, project_id: &str, location_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_cmek_config()
    ///         .set_cmek_config(
    ///             CmekConfig::new().set_name(format!("projects/{project_id}/locations/{location_id}/cmekConfig"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_cmek_config(&self) -> super::builder::cloud_tasks::UpdateCmekConfig {
        super::builder::cloud_tasks::UpdateCmekConfig::new(self.inner.clone())
    }

    /// Gets the CMEK config.
    ///
    /// Gets the Customer Managed Encryption Key configured with the Cloud Tasks
    /// location. By default there is no kms_key configured.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks, project_id: &str, location_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_cmek_config()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/cmekConfig"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_cmek_config(&self) -> super::builder::cloud_tasks::GetCmekConfig {
        super::builder::cloud_tasks::GetCmekConfig::new(self.inner.clone())
    }

    /// Lists information about the supported locations for this service.
    ///
    /// This method lists locations based on the resource scope provided in
    /// the [ListLocationsRequest.name][google.cloud.location.ListLocationsRequest.name] field: *
    /// **Global locations**: If `name` is empty, the method lists the
    /// public locations available to all projects. * **Project-specific
    /// locations**: If `name` follows the format
    /// `projects/{project}`, the method lists locations visible to that
    /// specific project. This includes public, private, or other
    /// project-specific locations enabled for the project.
    ///
    /// For gRPC and client library implementations, the resource name is
    /// passed as the `name` field. For direct service calls, the resource
    /// name is
    /// incorporated into the request path based on the specific service
    /// implementation and version.
    ///
    /// [google.cloud.location.ListLocationsRequest.name]: google_cloud_location::model::ListLocationsRequest::name
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks
    /// ) -> Result<()> {
    ///     let mut list = client.list_locations()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_locations(&self) -> super::builder::cloud_tasks::ListLocations {
        super::builder::cloud_tasks::ListLocations::new(self.inner.clone())
    }

    /// Gets information about a location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks
    /// ) -> Result<()> {
    ///     let response = client.get_location()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_location(&self) -> super::builder::cloud_tasks::GetLocation {
        super::builder::cloud_tasks::GetLocation::new(self.inner.clone())
    }

    /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
    ///
    /// [google.longrunning.Operations]: google-cloud-longrunning::client::Operations
    ///
    /// # Example
    /// ```
    /// # use google_cloud_tasks_v2::client::CloudTasks;
    /// use google_cloud_tasks_v2::Result;
    /// async fn sample(
    ///    client: &CloudTasks
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::cloud_tasks::GetOperation {
        super::builder::cloud_tasks::GetOperation::new(self.inner.clone())
    }
}