google-cloud-ces-v1 1.5.0

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

/// Implements a client for the Gemini Enterprise for Customer Experience API.
///
/// # Example
/// ```
/// # use google_cloud_ces_v1::client::AgentService;
/// use google_cloud_gax::paginator::ItemPaginator as _;
/// async fn sample(
///    project_id: &str,
///    location_id: &str,
///    app_id: &str,
/// ) -> anyhow::Result<()> {
///     let client = AgentService::builder().build().await?;
///     let mut list = client.list_agents()
///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
///         .by_item();
///     while let Some(item) = list.next().await.transpose()? {
///         println!("{:?}", item);
///     }
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// The service that manages agent-related resources in Gemini Enterprise for
/// Customer Engagement (CES).
///
/// # Configuration
///
/// To configure `AgentService` use the `with_*` methods in the type returned
/// by [builder()][AgentService::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://ces.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::agent_service::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::agent_service::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
///
/// `AgentService` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `AgentService` 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 AgentService {
    inner: std::sync::Arc<dyn super::stub::dynamic::AgentService>,
}

impl AgentService {
    /// Returns a builder for [AgentService].
    ///
    /// ```
    /// # async fn sample() -> google_cloud_gax::client_builder::Result<()> {
    /// # use google_cloud_ces_v1::client::AgentService;
    /// let client = AgentService::builder().build().await?;
    /// # Ok(()) }
    /// ```
    pub fn builder() -> super::builder::agent_service::ClientBuilder {
        crate::new_client_builder(super::builder::agent_service::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::AgentService + '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::AgentService>> {
        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::AgentService> {
        super::transport::AgentService::new(conf).await
    }

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

    /// Lists apps in the given project and location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_apps()
    ///         .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_apps(&self) -> super::builder::agent_service::ListApps {
        super::builder::agent_service::ListApps::new(self.inner.clone())
    }

    /// Gets details of the specified app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_app()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_app(&self) -> super::builder::agent_service::GetApp {
        super::builder::agent_service::GetApp::new(self.inner.clone())
    }

    /// Creates a new app in the given project and location.
    ///
    /// # 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_ces_v1::client::AgentService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_ces_v1::model::App;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_app()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}"))
    ///         .set_app_id("app_id_value")
    ///         .set_app(
    ///             App::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_app(&self) -> super::builder::agent_service::CreateApp {
        super::builder::agent_service::CreateApp::new(self.inner.clone())
    }

    /// Updates the specified app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_ces_v1::model::App;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_app()
    ///         .set_app(
    ///             App::new().set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_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_app(&self) -> super::builder::agent_service::UpdateApp {
        super::builder::agent_service::UpdateApp::new(self.inner.clone())
    }

    /// Deletes the specified app.
    ///
    /// # 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_ces_v1::client::AgentService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     client.delete_app()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_app(&self) -> super::builder::agent_service::DeleteApp {
        super::builder::agent_service::DeleteApp::new(self.inner.clone())
    }

    /// Exports the specified app.
    ///
    /// # 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_ces_v1::client::AgentService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService
    /// ) -> Result<()> {
    ///     let response = client.export_app()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn export_app(&self) -> super::builder::agent_service::ExportApp {
        super::builder::agent_service::ExportApp::new(self.inner.clone())
    }

    /// Imports the specified app.
    ///
    /// # 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_ces_v1::client::AgentService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService
    /// ) -> Result<()> {
    ///     let response = client.import_app()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn import_app(&self) -> super::builder::agent_service::ImportApp {
        super::builder::agent_service::ImportApp::new(self.inner.clone())
    }

    /// Lists agents in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_agents()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_agents(&self) -> super::builder::agent_service::ListAgents {
        super::builder::agent_service::ListAgents::new(self.inner.clone())
    }

    /// Gets details of the specified agent.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, agent_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_agent()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/agents/{agent_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_agent(&self) -> super::builder::agent_service::GetAgent {
        super::builder::agent_service::GetAgent::new(self.inner.clone())
    }

    /// Creates a new agent in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::model::Agent;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_agent()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .set_agent_id("agent_id_value")
    ///         .set_agent(
    ///             Agent::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_agent(&self) -> super::builder::agent_service::CreateAgent {
        super::builder::agent_service::CreateAgent::new(self.inner.clone())
    }

    /// Updates the specified agent.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_ces_v1::model::Agent;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, agent_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_agent()
    ///         .set_agent(
    ///             Agent::new().set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/agents/{agent_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_agent(&self) -> super::builder::agent_service::UpdateAgent {
        super::builder::agent_service::UpdateAgent::new(self.inner.clone())
    }

    /// Deletes the specified agent.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, agent_id: &str
    /// ) -> Result<()> {
    ///     client.delete_agent()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/agents/{agent_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_agent(&self) -> super::builder::agent_service::DeleteAgent {
        super::builder::agent_service::DeleteAgent::new(self.inner.clone())
    }

    /// Lists examples in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_examples()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_examples(&self) -> super::builder::agent_service::ListExamples {
        super::builder::agent_service::ListExamples::new(self.inner.clone())
    }

    /// Gets details of the specified example.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, example_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_example()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/examples/{example_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_example(&self) -> super::builder::agent_service::GetExample {
        super::builder::agent_service::GetExample::new(self.inner.clone())
    }

    /// Creates a new example in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::model::Example;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_example()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .set_example_id("example_id_value")
    ///         .set_example(
    ///             Example::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_example(&self) -> super::builder::agent_service::CreateExample {
        super::builder::agent_service::CreateExample::new(self.inner.clone())
    }

    /// Updates the specified example.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_ces_v1::model::Example;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, example_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_example()
    ///         .set_example(
    ///             Example::new().set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/examples/{example_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_example(&self) -> super::builder::agent_service::UpdateExample {
        super::builder::agent_service::UpdateExample::new(self.inner.clone())
    }

    /// Deletes the specified example.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, example_id: &str
    /// ) -> Result<()> {
    ///     client.delete_example()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/examples/{example_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_example(&self) -> super::builder::agent_service::DeleteExample {
        super::builder::agent_service::DeleteExample::new(self.inner.clone())
    }

    /// Lists tools in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_tools()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_tools(&self) -> super::builder::agent_service::ListTools {
        super::builder::agent_service::ListTools::new(self.inner.clone())
    }

    /// Gets details of the specified tool.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, tool_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_tool()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/tools/{tool_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_tool(&self) -> super::builder::agent_service::GetTool {
        super::builder::agent_service::GetTool::new(self.inner.clone())
    }

    /// Lists conversations in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_conversations()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_conversations(&self) -> super::builder::agent_service::ListConversations {
        super::builder::agent_service::ListConversations::new(self.inner.clone())
    }

    /// Gets details of the specified conversation.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, conversation_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_conversation()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/conversations/{conversation_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_conversation(&self) -> super::builder::agent_service::GetConversation {
        super::builder::agent_service::GetConversation::new(self.inner.clone())
    }

    /// Deletes the specified conversation.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, conversation_id: &str
    /// ) -> Result<()> {
    ///     client.delete_conversation()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/conversations/{conversation_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_conversation(&self) -> super::builder::agent_service::DeleteConversation {
        super::builder::agent_service::DeleteConversation::new(self.inner.clone())
    }

    /// Batch deletes the specified conversations.
    ///
    /// # 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_ces_v1::client::AgentService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService
    /// ) -> Result<()> {
    ///     let response = client.batch_delete_conversations()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn batch_delete_conversations(
        &self,
    ) -> super::builder::agent_service::BatchDeleteConversations {
        super::builder::agent_service::BatchDeleteConversations::new(self.inner.clone())
    }

    /// Creates a new tool in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::model::Tool;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_tool()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .set_tool_id("tool_id_value")
    ///         .set_tool(
    ///             Tool::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_tool(&self) -> super::builder::agent_service::CreateTool {
        super::builder::agent_service::CreateTool::new(self.inner.clone())
    }

    /// Updates the specified tool.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_ces_v1::model::Tool;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, tool_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_tool()
    ///         .set_tool(
    ///             Tool::new().set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/tools/{tool_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_tool(&self) -> super::builder::agent_service::UpdateTool {
        super::builder::agent_service::UpdateTool::new(self.inner.clone())
    }

    /// Deletes the specified tool.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, tool_id: &str
    /// ) -> Result<()> {
    ///     client.delete_tool()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/tools/{tool_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_tool(&self) -> super::builder::agent_service::DeleteTool {
        super::builder::agent_service::DeleteTool::new(self.inner.clone())
    }

    /// Lists guardrails in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_guardrails()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_guardrails(&self) -> super::builder::agent_service::ListGuardrails {
        super::builder::agent_service::ListGuardrails::new(self.inner.clone())
    }

    /// Gets details of the specified guardrail.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, guardrail_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_guardrail()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/guardrails/{guardrail_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_guardrail(&self) -> super::builder::agent_service::GetGuardrail {
        super::builder::agent_service::GetGuardrail::new(self.inner.clone())
    }

    /// Creates a new guardrail in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::model::Guardrail;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_guardrail()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .set_guardrail_id("guardrail_id_value")
    ///         .set_guardrail(
    ///             Guardrail::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_guardrail(&self) -> super::builder::agent_service::CreateGuardrail {
        super::builder::agent_service::CreateGuardrail::new(self.inner.clone())
    }

    /// Updates the specified guardrail.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_ces_v1::model::Guardrail;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, guardrail_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_guardrail()
    ///         .set_guardrail(
    ///             Guardrail::new().set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/guardrails/{guardrail_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_guardrail(&self) -> super::builder::agent_service::UpdateGuardrail {
        super::builder::agent_service::UpdateGuardrail::new(self.inner.clone())
    }

    /// Deletes the specified guardrail.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, guardrail_id: &str
    /// ) -> Result<()> {
    ///     client.delete_guardrail()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/guardrails/{guardrail_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_guardrail(&self) -> super::builder::agent_service::DeleteGuardrail {
        super::builder::agent_service::DeleteGuardrail::new(self.inner.clone())
    }

    /// Lists deployments in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_deployments()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_deployments(&self) -> super::builder::agent_service::ListDeployments {
        super::builder::agent_service::ListDeployments::new(self.inner.clone())
    }

    /// Gets details of the specified deployment.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, deployment_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_deployment()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/deployments/{deployment_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_deployment(&self) -> super::builder::agent_service::GetDeployment {
        super::builder::agent_service::GetDeployment::new(self.inner.clone())
    }

    /// Creates a new deployment in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::model::Deployment;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_deployment()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .set_deployment_id("deployment_id_value")
    ///         .set_deployment(
    ///             Deployment::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_deployment(&self) -> super::builder::agent_service::CreateDeployment {
        super::builder::agent_service::CreateDeployment::new(self.inner.clone())
    }

    /// Updates the specified deployment.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_ces_v1::model::Deployment;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, deployment_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_deployment()
    ///         .set_deployment(
    ///             Deployment::new().set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/deployments/{deployment_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_deployment(&self) -> super::builder::agent_service::UpdateDeployment {
        super::builder::agent_service::UpdateDeployment::new(self.inner.clone())
    }

    /// Deletes the specified deployment.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, deployment_id: &str
    /// ) -> Result<()> {
    ///     client.delete_deployment()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/deployments/{deployment_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_deployment(&self) -> super::builder::agent_service::DeleteDeployment {
        super::builder::agent_service::DeleteDeployment::new(self.inner.clone())
    }

    /// Lists toolsets in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_toolsets()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_toolsets(&self) -> super::builder::agent_service::ListToolsets {
        super::builder::agent_service::ListToolsets::new(self.inner.clone())
    }

    /// Gets details of the specified toolset.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, toolset_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_toolset()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/toolsets/{toolset_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_toolset(&self) -> super::builder::agent_service::GetToolset {
        super::builder::agent_service::GetToolset::new(self.inner.clone())
    }

    /// Creates a new toolset in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::model::Toolset;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_toolset()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .set_toolset_id("toolset_id_value")
    ///         .set_toolset(
    ///             Toolset::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_toolset(&self) -> super::builder::agent_service::CreateToolset {
        super::builder::agent_service::CreateToolset::new(self.inner.clone())
    }

    /// Updates the specified toolset.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_ces_v1::model::Toolset;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, toolset_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_toolset()
    ///         .set_toolset(
    ///             Toolset::new().set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/toolsets/{toolset_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_toolset(&self) -> super::builder::agent_service::UpdateToolset {
        super::builder::agent_service::UpdateToolset::new(self.inner.clone())
    }

    /// Deletes the specified toolset.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, toolset_id: &str
    /// ) -> Result<()> {
    ///     client.delete_toolset()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/toolsets/{toolset_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_toolset(&self) -> super::builder::agent_service::DeleteToolset {
        super::builder::agent_service::DeleteToolset::new(self.inner.clone())
    }

    /// Lists all app versions in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_app_versions()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_app_versions(&self) -> super::builder::agent_service::ListAppVersions {
        super::builder::agent_service::ListAppVersions::new(self.inner.clone())
    }

    /// Gets details of the specified app version.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, version_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_app_version()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/versions/{version_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_app_version(&self) -> super::builder::agent_service::GetAppVersion {
        super::builder::agent_service::GetAppVersion::new(self.inner.clone())
    }

    /// Creates a new app version in the given app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::model::AppVersion;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_app_version()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .set_app_version(
    ///             AppVersion::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_app_version(&self) -> super::builder::agent_service::CreateAppVersion {
        super::builder::agent_service::CreateAppVersion::new(self.inner.clone())
    }

    /// Deletes the specified app version.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, version_id: &str
    /// ) -> Result<()> {
    ///     client.delete_app_version()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/versions/{version_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_app_version(&self) -> super::builder::agent_service::DeleteAppVersion {
        super::builder::agent_service::DeleteAppVersion::new(self.inner.clone())
    }

    /// Restores the specified app version.
    /// This will create a new app version from the current draft app and overwrite
    /// the current draft with the specified app version.
    ///
    /// # 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_ces_v1::client::AgentService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService
    /// ) -> Result<()> {
    ///     let response = client.restore_app_version()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn restore_app_version(&self) -> super::builder::agent_service::RestoreAppVersion {
        super::builder::agent_service::RestoreAppVersion::new(self.inner.clone())
    }

    /// Lists the changelogs of the specified app.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_changelogs()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_changelogs(&self) -> super::builder::agent_service::ListChangelogs {
        super::builder::agent_service::ListChangelogs::new(self.inner.clone())
    }

    /// Gets the specified changelog.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService, project_id: &str, location_id: &str, app_id: &str, changelog_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_changelog()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/apps/{app_id}/changelogs/{changelog_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_changelog(&self) -> super::builder::agent_service::GetChangelog {
        super::builder::agent_service::GetChangelog::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_ces_v1::client::AgentService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService
    /// ) -> 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::agent_service::ListLocations {
        super::builder::agent_service::ListLocations::new(self.inner.clone())
    }

    /// Gets information about a location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService
    /// ) -> Result<()> {
    ///     let response = client.get_location()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_location(&self) -> super::builder::agent_service::GetLocation {
        super::builder::agent_service::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_ces_v1::client::AgentService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService
    /// ) -> Result<()> {
    ///     let mut list = client.list_operations()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_operations(&self) -> super::builder::agent_service::ListOperations {
        super::builder::agent_service::ListOperations::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_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::agent_service::GetOperation {
        super::builder::agent_service::GetOperation::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_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::agent_service::DeleteOperation {
        super::builder::agent_service::DeleteOperation::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_ces_v1::client::AgentService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &AgentService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::agent_service::CancelOperation {
        super::builder::agent_service::CancelOperation::new(self.inner.clone())
    }
}

/// Implements a client for the Gemini Enterprise for Customer Experience API.
///
/// # Example
/// ```
/// # use google_cloud_ces_v1::client::SessionService;
/// async fn sample(
/// ) -> anyhow::Result<()> {
///     let client = SessionService::builder().build().await?;
///     let response = client.run_session()
///         /* set fields */
///         .send().await?;
///     println!("response {:?}", response);
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// Session service provides APIs for interacting with CES agents.
///
/// # Configuration
///
/// To configure `SessionService` use the `with_*` methods in the type returned
/// by [builder()][SessionService::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://ces.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::session_service::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::session_service::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
///
/// `SessionService` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `SessionService` 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 SessionService {
    inner: std::sync::Arc<dyn super::stub::dynamic::SessionService>,
}

impl SessionService {
    /// Returns a builder for [SessionService].
    ///
    /// ```
    /// # async fn sample() -> google_cloud_gax::client_builder::Result<()> {
    /// # use google_cloud_ces_v1::client::SessionService;
    /// let client = SessionService::builder().build().await?;
    /// # Ok(()) }
    /// ```
    pub fn builder() -> super::builder::session_service::ClientBuilder {
        crate::new_client_builder(super::builder::session_service::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::SessionService + '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::SessionService>> {
        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::SessionService> {
        super::transport::SessionService::new(conf).await
    }

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

    /// Initiates a single-turn interaction with the CES agent within a session.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::SessionService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &SessionService
    /// ) -> Result<()> {
    ///     let response = client.run_session()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn run_session(&self) -> super::builder::session_service::RunSession {
        super::builder::session_service::RunSession::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_ces_v1::client::SessionService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &SessionService
    /// ) -> 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::session_service::ListLocations {
        super::builder::session_service::ListLocations::new(self.inner.clone())
    }

    /// Gets information about a location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::SessionService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &SessionService
    /// ) -> Result<()> {
    ///     let response = client.get_location()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_location(&self) -> super::builder::session_service::GetLocation {
        super::builder::session_service::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_ces_v1::client::SessionService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &SessionService
    /// ) -> Result<()> {
    ///     let mut list = client.list_operations()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_operations(&self) -> super::builder::session_service::ListOperations {
        super::builder::session_service::ListOperations::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_ces_v1::client::SessionService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &SessionService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::session_service::GetOperation {
        super::builder::session_service::GetOperation::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_ces_v1::client::SessionService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &SessionService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::session_service::DeleteOperation {
        super::builder::session_service::DeleteOperation::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_ces_v1::client::SessionService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &SessionService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::session_service::CancelOperation {
        super::builder::session_service::CancelOperation::new(self.inner.clone())
    }
}

/// Implements a client for the Gemini Enterprise for Customer Experience API.
///
/// # Example
/// ```
/// # use google_cloud_ces_v1::client::ToolService;
/// async fn sample(
/// ) -> anyhow::Result<()> {
///     let client = ToolService::builder().build().await?;
///     let response = client.execute_tool()
///         /* set fields */
///         .send().await?;
///     println!("response {:?}", response);
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// Tool service provides APIs for interacting with CES tools.
///
/// # Configuration
///
/// To configure `ToolService` use the `with_*` methods in the type returned
/// by [builder()][ToolService::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://ces.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::tool_service::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::tool_service::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
///
/// `ToolService` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `ToolService` 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 ToolService {
    inner: std::sync::Arc<dyn super::stub::dynamic::ToolService>,
}

impl ToolService {
    /// Returns a builder for [ToolService].
    ///
    /// ```
    /// # async fn sample() -> google_cloud_gax::client_builder::Result<()> {
    /// # use google_cloud_ces_v1::client::ToolService;
    /// let client = ToolService::builder().build().await?;
    /// # Ok(()) }
    /// ```
    pub fn builder() -> super::builder::tool_service::ClientBuilder {
        crate::new_client_builder(super::builder::tool_service::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::ToolService + '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::ToolService>> {
        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::ToolService> {
        super::transport::ToolService::new(conf).await
    }

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

    /// Executes the given tool with the given arguments.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::ToolService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &ToolService
    /// ) -> Result<()> {
    ///     let response = client.execute_tool()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn execute_tool(&self) -> super::builder::tool_service::ExecuteTool {
        super::builder::tool_service::ExecuteTool::new(self.inner.clone())
    }

    /// Retrieve the schema of the given tool. The schema is computed on the fly
    /// for the given instance of the tool.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::ToolService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &ToolService
    /// ) -> Result<()> {
    ///     let response = client.retrieve_tool_schema()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn retrieve_tool_schema(&self) -> super::builder::tool_service::RetrieveToolSchema {
        super::builder::tool_service::RetrieveToolSchema::new(self.inner.clone())
    }

    /// Retrieve the list of tools included in the specified toolset.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::ToolService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &ToolService
    /// ) -> Result<()> {
    ///     let response = client.retrieve_tools()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn retrieve_tools(&self) -> super::builder::tool_service::RetrieveTools {
        super::builder::tool_service::RetrieveTools::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_ces_v1::client::ToolService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &ToolService
    /// ) -> 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::tool_service::ListLocations {
        super::builder::tool_service::ListLocations::new(self.inner.clone())
    }

    /// Gets information about a location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::ToolService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &ToolService
    /// ) -> Result<()> {
    ///     let response = client.get_location()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_location(&self) -> super::builder::tool_service::GetLocation {
        super::builder::tool_service::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_ces_v1::client::ToolService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &ToolService
    /// ) -> Result<()> {
    ///     let mut list = client.list_operations()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_operations(&self) -> super::builder::tool_service::ListOperations {
        super::builder::tool_service::ListOperations::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_ces_v1::client::ToolService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &ToolService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::tool_service::GetOperation {
        super::builder::tool_service::GetOperation::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_ces_v1::client::ToolService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &ToolService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::tool_service::DeleteOperation {
        super::builder::tool_service::DeleteOperation::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_ces_v1::client::ToolService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &ToolService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::tool_service::CancelOperation {
        super::builder::tool_service::CancelOperation::new(self.inner.clone())
    }
}

/// Implements a client for the Gemini Enterprise for Customer Experience API.
///
/// # Example
/// ```
/// # use google_cloud_ces_v1::client::WidgetService;
/// async fn sample(
/// ) -> anyhow::Result<()> {
///     let client = WidgetService::builder().build().await?;
///     let response = client.generate_chat_token()
///         /* set fields */
///         .send().await?;
///     println!("response {:?}", response);
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// Provides APIs for widgets to interact with CES APIs.
///
/// # Configuration
///
/// To configure `WidgetService` use the `with_*` methods in the type returned
/// by [builder()][WidgetService::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://ces.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::widget_service::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::widget_service::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
///
/// `WidgetService` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `WidgetService` 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 WidgetService {
    inner: std::sync::Arc<dyn super::stub::dynamic::WidgetService>,
}

impl WidgetService {
    /// Returns a builder for [WidgetService].
    ///
    /// ```
    /// # async fn sample() -> google_cloud_gax::client_builder::Result<()> {
    /// # use google_cloud_ces_v1::client::WidgetService;
    /// let client = WidgetService::builder().build().await?;
    /// # Ok(()) }
    /// ```
    pub fn builder() -> super::builder::widget_service::ClientBuilder {
        crate::new_client_builder(super::builder::widget_service::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::WidgetService + '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::WidgetService>> {
        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::WidgetService> {
        super::transport::WidgetService::new(conf).await
    }

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

    /// Generates a session scoped token for chat widget to authenticate with
    /// Session APIs.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::WidgetService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &WidgetService
    /// ) -> Result<()> {
    ///     let response = client.generate_chat_token()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn generate_chat_token(&self) -> super::builder::widget_service::GenerateChatToken {
        super::builder::widget_service::GenerateChatToken::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_ces_v1::client::WidgetService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &WidgetService
    /// ) -> 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::widget_service::ListLocations {
        super::builder::widget_service::ListLocations::new(self.inner.clone())
    }

    /// Gets information about a location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_ces_v1::client::WidgetService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &WidgetService
    /// ) -> Result<()> {
    ///     let response = client.get_location()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_location(&self) -> super::builder::widget_service::GetLocation {
        super::builder::widget_service::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_ces_v1::client::WidgetService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &WidgetService
    /// ) -> Result<()> {
    ///     let mut list = client.list_operations()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_operations(&self) -> super::builder::widget_service::ListOperations {
        super::builder::widget_service::ListOperations::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_ces_v1::client::WidgetService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &WidgetService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::widget_service::GetOperation {
        super::builder::widget_service::GetOperation::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_ces_v1::client::WidgetService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &WidgetService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::widget_service::DeleteOperation {
        super::builder::widget_service::DeleteOperation::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_ces_v1::client::WidgetService;
    /// use google_cloud_ces_v1::Result;
    /// async fn sample(
    ///    client: &WidgetService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::widget_service::CancelOperation {
        super::builder::widget_service::CancelOperation::new(self.inner.clone())
    }
}