google_cloud_visionai_v1/

client.rs

// 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 Vision AI API.
///
/// # Example
/// ```
/// # use google_cloud_visionai_v1::client::HealthCheckService;
/// async fn sample(
/// ) -> anyhow::Result<()> {
///     let client = HealthCheckService::builder().build().await?;
///     let response = client.health_check()
///         /* set fields */
///         .send().await?;
///     println!("response {:?}", response);
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// HealthCheckService provides an interface for Vertex AI Vision Cluster Health
/// Check.
///
/// # Configuration
///
/// To configure `HealthCheckService` use the `with_*` methods in the type returned
/// by [builder()][HealthCheckService::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://visionai.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::health_check_service::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::health_check_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
///
/// `HealthCheckService` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `HealthCheckService` 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 HealthCheckService {
    inner: std::sync::Arc<dyn super::stub::dynamic::HealthCheckService>,
}

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

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

    /// HealthCheck method checks the health status of the cluster.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::HealthCheckService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &HealthCheckService
    /// ) -> Result<()> {
    ///     let response = client.health_check()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn health_check(&self) -> super::builder::health_check_service::HealthCheck {
        super::builder::health_check_service::HealthCheck::new(self.inner.clone())
    }

    /// Lists information about the supported locations for this service.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::HealthCheckService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &HealthCheckService
    /// ) -> 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::health_check_service::ListLocations {
        super::builder::health_check_service::ListLocations::new(self.inner.clone())
    }

    /// Gets information about a location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::HealthCheckService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &HealthCheckService
    /// ) -> Result<()> {
    ///     let response = client.get_location()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_location(&self) -> super::builder::health_check_service::GetLocation {
        super::builder::health_check_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_visionai_v1::client::HealthCheckService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &HealthCheckService
    /// ) -> 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::health_check_service::ListOperations {
        super::builder::health_check_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_visionai_v1::client::HealthCheckService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &HealthCheckService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::health_check_service::GetOperation {
        super::builder::health_check_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_visionai_v1::client::HealthCheckService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &HealthCheckService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::health_check_service::DeleteOperation {
        super::builder::health_check_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_visionai_v1::client::HealthCheckService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &HealthCheckService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::health_check_service::CancelOperation {
        super::builder::health_check_service::CancelOperation::new(self.inner.clone())
    }
}

/// Implements a client for the Vision AI API.
///
/// # Example
/// ```
/// # use google_cloud_visionai_v1::client::LiveVideoAnalytics;
/// use google_cloud_gax::paginator::ItemPaginator as _;
/// async fn sample(
///    parent: &str,
/// ) -> anyhow::Result<()> {
///     let client = LiveVideoAnalytics::builder().build().await?;
///     let mut list = client.list_public_operators()
///         .set_parent(parent)
///         .by_item();
///     while let Some(item) = list.next().await.transpose()? {
///         println!("{:?}", item);
///     }
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// Service describing handlers for resources. The service enables clients to run
/// Live Video Analytics (LVA) on the streaming inputs.
///
/// # Configuration
///
/// To configure `LiveVideoAnalytics` use the `with_*` methods in the type returned
/// by [builder()][LiveVideoAnalytics::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://visionai.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::live_video_analytics::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::live_video_analytics::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
///
/// `LiveVideoAnalytics` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `LiveVideoAnalytics` 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 LiveVideoAnalytics {
    inner: std::sync::Arc<dyn super::stub::dynamic::LiveVideoAnalytics>,
}

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

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

    /// ListPublicOperators returns all the operators in public registry.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_public_operators()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_public_operators(
        &self,
    ) -> super::builder::live_video_analytics::ListPublicOperators {
        super::builder::live_video_analytics::ListPublicOperators::new(self.inner.clone())
    }

    /// ResolveOperatorInfo returns the operator information based on the request.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics
    /// ) -> Result<()> {
    ///     let response = client.resolve_operator_info()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn resolve_operator_info(
        &self,
    ) -> super::builder::live_video_analytics::ResolveOperatorInfo {
        super::builder::live_video_analytics::ResolveOperatorInfo::new(self.inner.clone())
    }

    /// Lists Operators in a given project and location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_operators()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_operators(&self) -> super::builder::live_video_analytics::ListOperators {
        super::builder::live_video_analytics::ListOperators::new(self.inner.clone())
    }

    /// Gets details of a single Operator.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, project_id: &str, location_id: &str, operator_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_operator()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/operators/{operator_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operator(&self) -> super::builder::live_video_analytics::GetOperator {
        super::builder::live_video_analytics::GetOperator::new(self.inner.clone())
    }

    /// Creates a new Operator in a 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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::Operator;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_operator()
    ///         .set_parent(parent)
    ///         .set_operator_id("operator_id_value")
    ///         .set_operator(
    ///             Operator::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_operator(&self) -> super::builder::live_video_analytics::CreateOperator {
        super::builder::live_video_analytics::CreateOperator::new(self.inner.clone())
    }

    /// Updates the parameters of a single Operator.
    ///
    /// # 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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Operator;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, project_id: &str, location_id: &str, operator_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_operator()
    ///         .set_operator(
    ///             Operator::new().set_name(format!("projects/{project_id}/locations/{location_id}/operators/{operator_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_operator(&self) -> super::builder::live_video_analytics::UpdateOperator {
        super::builder::live_video_analytics::UpdateOperator::new(self.inner.clone())
    }

    /// Deletes a single Operator.
    ///
    /// # 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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, project_id: &str, location_id: &str, operator_id: &str
    /// ) -> Result<()> {
    ///     client.delete_operator()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/operators/{operator_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operator(&self) -> super::builder::live_video_analytics::DeleteOperator {
        super::builder::live_video_analytics::DeleteOperator::new(self.inner.clone())
    }

    /// Lists Analyses in a given project and location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, project_id: &str, location_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_analyses()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_analyses(&self) -> super::builder::live_video_analytics::ListAnalyses {
        super::builder::live_video_analytics::ListAnalyses::new(self.inner.clone())
    }

    /// Gets details of a single Analysis.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, project_id: &str, location_id: &str, cluster_id: &str, analysis_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_analysis()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/analyses/{analysis_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_analysis(&self) -> super::builder::live_video_analytics::GetAnalysis {
        super::builder::live_video_analytics::GetAnalysis::new(self.inner.clone())
    }

    /// Creates a new Analysis in a 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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::Analysis;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, project_id: &str, location_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_analysis()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))
    ///         .set_analysis_id("analysis_id_value")
    ///         .set_analysis(
    ///             Analysis::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_analysis(&self) -> super::builder::live_video_analytics::CreateAnalysis {
        super::builder::live_video_analytics::CreateAnalysis::new(self.inner.clone())
    }

    /// Updates the parameters of a single Analysis.
    ///
    /// # 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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Analysis;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, project_id: &str, location_id: &str, cluster_id: &str, analysis_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_analysis()
    ///         .set_analysis(
    ///             Analysis::new().set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/analyses/{analysis_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_analysis(&self) -> super::builder::live_video_analytics::UpdateAnalysis {
        super::builder::live_video_analytics::UpdateAnalysis::new(self.inner.clone())
    }

    /// Deletes a single Analysis.
    ///
    /// # 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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, project_id: &str, location_id: &str, cluster_id: &str, analysis_id: &str
    /// ) -> Result<()> {
    ///     client.delete_analysis()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/analyses/{analysis_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_analysis(&self) -> super::builder::live_video_analytics::DeleteAnalysis {
        super::builder::live_video_analytics::DeleteAnalysis::new(self.inner.clone())
    }

    /// Lists Processes in a given project and location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, project_id: &str, location_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_processes()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_processes(&self) -> super::builder::live_video_analytics::ListProcesses {
        super::builder::live_video_analytics::ListProcesses::new(self.inner.clone())
    }

    /// Gets details of a single Process.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, project_id: &str, location_id: &str, cluster_id: &str, process_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_process()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/processes/{process_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_process(&self) -> super::builder::live_video_analytics::GetProcess {
        super::builder::live_video_analytics::GetProcess::new(self.inner.clone())
    }

    /// Creates a new Process in a 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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::Process;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, project_id: &str, location_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_process()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))
    ///         .set_process_id("process_id_value")
    ///         .set_process(
    ///             Process::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_process(&self) -> super::builder::live_video_analytics::CreateProcess {
        super::builder::live_video_analytics::CreateProcess::new(self.inner.clone())
    }

    /// Updates the parameters of a single Process.
    ///
    /// # 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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Process;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, project_id: &str, location_id: &str, cluster_id: &str, process_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_process()
    ///         .set_process(
    ///             Process::new().set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/processes/{process_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_process(&self) -> super::builder::live_video_analytics::UpdateProcess {
        super::builder::live_video_analytics::UpdateProcess::new(self.inner.clone())
    }

    /// Deletes a single Process.
    ///
    /// # 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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics, project_id: &str, location_id: &str, cluster_id: &str, process_id: &str
    /// ) -> Result<()> {
    ///     client.delete_process()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/processes/{process_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_process(&self) -> super::builder::live_video_analytics::DeleteProcess {
        super::builder::live_video_analytics::DeleteProcess::new(self.inner.clone())
    }

    /// Run all of the processes to "completion". Max time for each process is
    /// the LRO time limit.
    ///
    /// # 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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics
    /// ) -> Result<()> {
    ///     let response = client.batch_run_process()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn batch_run_process(&self) -> super::builder::live_video_analytics::BatchRunProcess {
        super::builder::live_video_analytics::BatchRunProcess::new(self.inner.clone())
    }

    /// Lists information about the supported locations for this service.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics
    /// ) -> 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::live_video_analytics::ListLocations {
        super::builder::live_video_analytics::ListLocations::new(self.inner.clone())
    }

    /// Gets information about a location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics
    /// ) -> Result<()> {
    ///     let response = client.get_location()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_location(&self) -> super::builder::live_video_analytics::GetLocation {
        super::builder::live_video_analytics::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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics
    /// ) -> 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::live_video_analytics::ListOperations {
        super::builder::live_video_analytics::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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::live_video_analytics::GetOperation {
        super::builder::live_video_analytics::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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::live_video_analytics::DeleteOperation {
        super::builder::live_video_analytics::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_visionai_v1::client::LiveVideoAnalytics;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &LiveVideoAnalytics
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::live_video_analytics::CancelOperation {
        super::builder::live_video_analytics::CancelOperation::new(self.inner.clone())
    }
}

/// Implements a client for the Vision AI API.
///
/// # Example
/// ```
/// # use google_cloud_visionai_v1::client::AppPlatform;
/// use google_cloud_gax::paginator::ItemPaginator as _;
/// async fn sample(
///    project_id: &str,
///    location_id: &str,
/// ) -> anyhow::Result<()> {
///     let client = AppPlatform::builder().build().await?;
///     let mut list = client.list_applications()
///         .set_parent(format!("projects/{project_id}/locations/{location_id}"))
///         .by_item();
///     while let Some(item) = list.next().await.transpose()? {
///         println!("{:?}", item);
///     }
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// Service describing handlers for resources
///
/// # Configuration
///
/// To configure `AppPlatform` use the `with_*` methods in the type returned
/// by [builder()][AppPlatform::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://visionai.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::app_platform::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::app_platform::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
///
/// `AppPlatform` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `AppPlatform` 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 AppPlatform {
    inner: std::sync::Arc<dyn super::stub::dynamic::AppPlatform>,
}

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

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

    /// Lists Applications in a given project and location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::AppPlatform;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_applications()
    ///         .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_applications(&self) -> super::builder::app_platform::ListApplications {
        super::builder::app_platform::ListApplications::new(self.inner.clone())
    }

    /// Gets details of a single Application.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::AppPlatform;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, application_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_application()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/applications/{application_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_application(&self) -> super::builder::app_platform::GetApplication {
        super::builder::app_platform::GetApplication::new(self.inner.clone())
    }

    /// Creates a new Application in a 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::Application;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_application()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}"))
    ///         .set_application_id("application_id_value")
    ///         .set_application(
    ///             Application::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_application(&self) -> super::builder::app_platform::CreateApplication {
        super::builder::app_platform::CreateApplication::new(self.inner.clone())
    }

    /// Updates the parameters of a single Application.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Application;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, application_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_application()
    ///         .set_application(
    ///             Application::new().set_name(format!("projects/{project_id}/locations/{location_id}/applications/{application_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_application(&self) -> super::builder::app_platform::UpdateApplication {
        super::builder::app_platform::UpdateApplication::new(self.inner.clone())
    }

    /// Deletes a single Application.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, application_id: &str
    /// ) -> Result<()> {
    ///     client.delete_application()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/applications/{application_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_application(&self) -> super::builder::app_platform::DeleteApplication {
        super::builder::app_platform::DeleteApplication::new(self.inner.clone())
    }

    /// Deploys a single Application.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> Result<()> {
    ///     let response = client.deploy_application()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn deploy_application(&self) -> super::builder::app_platform::DeployApplication {
        super::builder::app_platform::DeployApplication::new(self.inner.clone())
    }

    /// Undeploys a single Application.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> Result<()> {
    ///     let response = client.undeploy_application()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn undeploy_application(&self) -> super::builder::app_platform::UndeployApplication {
        super::builder::app_platform::UndeployApplication::new(self.inner.clone())
    }

    /// Adds target stream input to the Application.
    /// If the Application is deployed, the corresponding new Application instance
    /// will be created. If the stream has already been in the Application, the RPC
    /// will fail.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> Result<()> {
    ///     let response = client.add_application_stream_input()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn add_application_stream_input(
        &self,
    ) -> super::builder::app_platform::AddApplicationStreamInput {
        super::builder::app_platform::AddApplicationStreamInput::new(self.inner.clone())
    }

    /// Remove target stream input to the Application, if the Application is
    /// deployed, the corresponding instance based will be deleted. If the stream
    /// is not in the Application, the RPC will fail.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> Result<()> {
    ///     let response = client.remove_application_stream_input()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn remove_application_stream_input(
        &self,
    ) -> super::builder::app_platform::RemoveApplicationStreamInput {
        super::builder::app_platform::RemoveApplicationStreamInput::new(self.inner.clone())
    }

    /// Update target stream input to the Application, if the Application is
    /// deployed, the corresponding instance based will be deployed. For
    /// CreateOrUpdate behavior, set allow_missing to true.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> Result<()> {
    ///     let response = client.update_application_stream_input()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_application_stream_input(
        &self,
    ) -> super::builder::app_platform::UpdateApplicationStreamInput {
        super::builder::app_platform::UpdateApplicationStreamInput::new(self.inner.clone())
    }

    /// Lists Instances in a given project and location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::AppPlatform;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, application_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_instances()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/applications/{application_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_instances(&self) -> super::builder::app_platform::ListInstances {
        super::builder::app_platform::ListInstances::new(self.inner.clone())
    }

    /// Gets details of a single Instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::AppPlatform;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, application_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_instance()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/applications/{application_id}/instances/{instance_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_instance(&self) -> super::builder::app_platform::GetInstance {
        super::builder::app_platform::GetInstance::new(self.inner.clone())
    }

    /// Adds target stream input to the Application.
    /// If the Application is deployed, the corresponding new Application instance
    /// will be created. If the stream has already been in the Application, the RPC
    /// will fail.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> Result<()> {
    ///     let response = client.create_application_instances()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_application_instances(
        &self,
    ) -> super::builder::app_platform::CreateApplicationInstances {
        super::builder::app_platform::CreateApplicationInstances::new(self.inner.clone())
    }

    /// Remove target stream input to the Application, if the Application is
    /// deployed, the corresponding instance based will be deleted. If the stream
    /// is not in the Application, the RPC will fail.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, application_id: &str
    /// ) -> Result<()> {
    ///     let response = client.delete_application_instances()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/applications/{application_id}"))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_application_instances(
        &self,
    ) -> super::builder::app_platform::DeleteApplicationInstances {
        super::builder::app_platform::DeleteApplicationInstances::new(self.inner.clone())
    }

    /// Adds target stream input to the Application.
    /// If the Application is deployed, the corresponding new Application instance
    /// will be created. If the stream has already been in the Application, the RPC
    /// will fail.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> Result<()> {
    ///     let response = client.update_application_instances()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_application_instances(
        &self,
    ) -> super::builder::app_platform::UpdateApplicationInstances {
        super::builder::app_platform::UpdateApplicationInstances::new(self.inner.clone())
    }

    /// Lists Drafts in a given project and location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::AppPlatform;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, application_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_drafts()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/applications/{application_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_drafts(&self) -> super::builder::app_platform::ListDrafts {
        super::builder::app_platform::ListDrafts::new(self.inner.clone())
    }

    /// Gets details of a single Draft.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::AppPlatform;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, application_id: &str, draft_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_draft()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/applications/{application_id}/drafts/{draft_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_draft(&self) -> super::builder::app_platform::GetDraft {
        super::builder::app_platform::GetDraft::new(self.inner.clone())
    }

    /// Creates a new Draft in a 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::Draft;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, application_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_draft()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/applications/{application_id}"))
    ///         .set_draft_id("draft_id_value")
    ///         .set_draft(
    ///             Draft::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_draft(&self) -> super::builder::app_platform::CreateDraft {
        super::builder::app_platform::CreateDraft::new(self.inner.clone())
    }

    /// Updates the parameters of a single Draft.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Draft;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, application_id: &str, draft_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_draft()
    ///         .set_draft(
    ///             Draft::new().set_name(format!("projects/{project_id}/locations/{location_id}/applications/{application_id}/drafts/{draft_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_draft(&self) -> super::builder::app_platform::UpdateDraft {
        super::builder::app_platform::UpdateDraft::new(self.inner.clone())
    }

    /// Deletes a single Draft.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, application_id: &str, draft_id: &str
    /// ) -> Result<()> {
    ///     client.delete_draft()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/applications/{application_id}/drafts/{draft_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_draft(&self) -> super::builder::app_platform::DeleteDraft {
        super::builder::app_platform::DeleteDraft::new(self.inner.clone())
    }

    /// Lists Processors in a given project and location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::AppPlatform;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_processors()
    ///         .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_processors(&self) -> super::builder::app_platform::ListProcessors {
        super::builder::app_platform::ListProcessors::new(self.inner.clone())
    }

    /// ListPrebuiltProcessors is a custom pass-through verb that Lists Prebuilt
    /// Processors.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::AppPlatform;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> Result<()> {
    ///     let response = client.list_prebuilt_processors()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn list_prebuilt_processors(&self) -> super::builder::app_platform::ListPrebuiltProcessors {
        super::builder::app_platform::ListPrebuiltProcessors::new(self.inner.clone())
    }

    /// Gets details of a single Processor.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::AppPlatform;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, processor_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_processor()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/processors/{processor_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_processor(&self) -> super::builder::app_platform::GetProcessor {
        super::builder::app_platform::GetProcessor::new(self.inner.clone())
    }

    /// Creates a new Processor in a 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::Processor;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_processor()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}"))
    ///         .set_processor_id("processor_id_value")
    ///         .set_processor(
    ///             Processor::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_processor(&self) -> super::builder::app_platform::CreateProcessor {
        super::builder::app_platform::CreateProcessor::new(self.inner.clone())
    }

    /// Updates the parameters of a single Processor.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Processor;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, processor_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_processor()
    ///         .set_processor(
    ///             Processor::new().set_name(format!("projects/{project_id}/locations/{location_id}/processors/{processor_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_processor(&self) -> super::builder::app_platform::UpdateProcessor {
        super::builder::app_platform::UpdateProcessor::new(self.inner.clone())
    }

    /// Deletes a single Processor.
    ///
    /// # 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_visionai_v1::client::AppPlatform;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform, project_id: &str, location_id: &str, processor_id: &str
    /// ) -> Result<()> {
    ///     client.delete_processor()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/processors/{processor_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_processor(&self) -> super::builder::app_platform::DeleteProcessor {
        super::builder::app_platform::DeleteProcessor::new(self.inner.clone())
    }

    /// Lists information about the supported locations for this service.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::AppPlatform;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> 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::app_platform::ListLocations {
        super::builder::app_platform::ListLocations::new(self.inner.clone())
    }

    /// Gets information about a location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::AppPlatform;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> Result<()> {
    ///     let response = client.get_location()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_location(&self) -> super::builder::app_platform::GetLocation {
        super::builder::app_platform::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_visionai_v1::client::AppPlatform;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> 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::app_platform::ListOperations {
        super::builder::app_platform::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_visionai_v1::client::AppPlatform;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::app_platform::GetOperation {
        super::builder::app_platform::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_visionai_v1::client::AppPlatform;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::app_platform::DeleteOperation {
        super::builder::app_platform::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_visionai_v1::client::AppPlatform;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &AppPlatform
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::app_platform::CancelOperation {
        super::builder::app_platform::CancelOperation::new(self.inner.clone())
    }
}

/// Implements a client for the Vision AI API.
///
/// # Example
/// ```
/// # use google_cloud_visionai_v1::client::StreamingService;
/// async fn sample(
/// ) -> anyhow::Result<()> {
///     let client = StreamingService::builder().build().await?;
///     let response = client.acquire_lease()
///         /* set fields */
///         .send().await?;
///     println!("response {:?}", response);
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// Streaming service for receiving and sending packets.
///
/// # Configuration
///
/// To configure `StreamingService` use the `with_*` methods in the type returned
/// by [builder()][StreamingService::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://visionai.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::streaming_service::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::streaming_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
///
/// `StreamingService` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `StreamingService` 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 StreamingService {
    inner: std::sync::Arc<dyn super::stub::dynamic::StreamingService>,
}

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

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

    /// AcquireLease acquires a lease.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamingService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamingService
    /// ) -> Result<()> {
    ///     let response = client.acquire_lease()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn acquire_lease(&self) -> super::builder::streaming_service::AcquireLease {
        super::builder::streaming_service::AcquireLease::new(self.inner.clone())
    }

    /// RenewLease renews a lease.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamingService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamingService
    /// ) -> Result<()> {
    ///     let response = client.renew_lease()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn renew_lease(&self) -> super::builder::streaming_service::RenewLease {
        super::builder::streaming_service::RenewLease::new(self.inner.clone())
    }

    /// RleaseLease releases a lease.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamingService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamingService
    /// ) -> Result<()> {
    ///     let response = client.release_lease()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn release_lease(&self) -> super::builder::streaming_service::ReleaseLease {
        super::builder::streaming_service::ReleaseLease::new(self.inner.clone())
    }

    /// Lists information about the supported locations for this service.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamingService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamingService
    /// ) -> 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::streaming_service::ListLocations {
        super::builder::streaming_service::ListLocations::new(self.inner.clone())
    }

    /// Gets information about a location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamingService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamingService
    /// ) -> Result<()> {
    ///     let response = client.get_location()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_location(&self) -> super::builder::streaming_service::GetLocation {
        super::builder::streaming_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_visionai_v1::client::StreamingService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamingService
    /// ) -> 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::streaming_service::ListOperations {
        super::builder::streaming_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_visionai_v1::client::StreamingService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamingService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::streaming_service::GetOperation {
        super::builder::streaming_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_visionai_v1::client::StreamingService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamingService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::streaming_service::DeleteOperation {
        super::builder::streaming_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_visionai_v1::client::StreamingService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamingService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::streaming_service::CancelOperation {
        super::builder::streaming_service::CancelOperation::new(self.inner.clone())
    }
}

/// Implements a client for the Vision AI API.
///
/// # Example
/// ```
/// # use google_cloud_visionai_v1::client::StreamsService;
/// use google_cloud_gax::paginator::ItemPaginator as _;
/// async fn sample(
///    project_id: &str,
///    location_id: &str,
///    cluster_id: &str,
/// ) -> anyhow::Result<()> {
///     let client = StreamsService::builder().build().await?;
///     let mut list = client.list_streams()
///         .set_parent(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))
///         .by_item();
///     while let Some(item) = list.next().await.transpose()? {
///         println!("{:?}", item);
///     }
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// Service describing handlers for resources.
/// Vision API and Vision AI API are two independent APIs developed by the same
/// team. Vision API is for people to annotate their image while Vision AI is an
/// e2e solution for customer to build their own computer vision application.
///
/// # Configuration
///
/// To configure `StreamsService` use the `with_*` methods in the type returned
/// by [builder()][StreamsService::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://visionai.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::streams_service::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::streams_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
///
/// `StreamsService` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `StreamsService` 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 StreamsService {
    inner: std::sync::Arc<dyn super::stub::dynamic::StreamsService>,
}

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

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

    /// Lists Clusters in a given project and location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamsService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_clusters()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_clusters(&self) -> super::builder::streams_service::ListClusters {
        super::builder::streams_service::ListClusters::new(self.inner.clone())
    }

    /// Gets details of a single Cluster.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamsService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_cluster()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_cluster(&self) -> super::builder::streams_service::GetCluster {
        super::builder::streams_service::GetCluster::new(self.inner.clone())
    }

    /// Creates a new Cluster in a 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::Cluster;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_cluster()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}"))
    ///         .set_cluster_id("cluster_id_value")
    ///         .set_cluster(
    ///             Cluster::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_cluster(&self) -> super::builder::streams_service::CreateCluster {
        super::builder::streams_service::CreateCluster::new(self.inner.clone())
    }

    /// Updates the parameters of a single Cluster.
    ///
    /// # 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Cluster;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_cluster()
    ///         .set_cluster(
    ///             Cluster::new().set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_cluster(&self) -> super::builder::streams_service::UpdateCluster {
        super::builder::streams_service::UpdateCluster::new(self.inner.clone())
    }

    /// Deletes a single Cluster.
    ///
    /// # 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     client.delete_cluster()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_cluster(&self) -> super::builder::streams_service::DeleteCluster {
        super::builder::streams_service::DeleteCluster::new(self.inner.clone())
    }

    /// Lists Streams in a given project and location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamsService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_streams()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_streams(&self) -> super::builder::streams_service::ListStreams {
        super::builder::streams_service::ListStreams::new(self.inner.clone())
    }

    /// Gets details of a single Stream.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamsService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str, stream_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_stream()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/streams/{stream_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_stream(&self) -> super::builder::streams_service::GetStream {
        super::builder::streams_service::GetStream::new(self.inner.clone())
    }

    /// Creates a new Stream in a 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::Stream;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_stream()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))
    ///         .set_stream_id("stream_id_value")
    ///         .set_stream(
    ///             Stream::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_stream(&self) -> super::builder::streams_service::CreateStream {
        super::builder::streams_service::CreateStream::new(self.inner.clone())
    }

    /// Updates the parameters of a single Stream.
    ///
    /// # 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Stream;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str, stream_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_stream()
    ///         .set_stream(
    ///             Stream::new().set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/streams/{stream_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_stream(&self) -> super::builder::streams_service::UpdateStream {
        super::builder::streams_service::UpdateStream::new(self.inner.clone())
    }

    /// Deletes a single Stream.
    ///
    /// # 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str, stream_id: &str
    /// ) -> Result<()> {
    ///     client.delete_stream()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/streams/{stream_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_stream(&self) -> super::builder::streams_service::DeleteStream {
        super::builder::streams_service::DeleteStream::new(self.inner.clone())
    }

    /// Gets the thumbnail (image snapshot) of a single Stream.
    ///
    /// # 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService
    /// ) -> Result<()> {
    ///     let response = client.get_stream_thumbnail()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_stream_thumbnail(&self) -> super::builder::streams_service::GetStreamThumbnail {
        super::builder::streams_service::GetStreamThumbnail::new(self.inner.clone())
    }

    /// Generate the JWT auth token required to get the stream HLS contents.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamsService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService
    /// ) -> Result<()> {
    ///     let response = client.generate_stream_hls_token()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn generate_stream_hls_token(
        &self,
    ) -> super::builder::streams_service::GenerateStreamHlsToken {
        super::builder::streams_service::GenerateStreamHlsToken::new(self.inner.clone())
    }

    /// Lists Events in a given project and location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamsService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_events()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_events(&self) -> super::builder::streams_service::ListEvents {
        super::builder::streams_service::ListEvents::new(self.inner.clone())
    }

    /// Gets details of a single Event.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamsService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str, event_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_event()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/events/{event_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_event(&self) -> super::builder::streams_service::GetEvent {
        super::builder::streams_service::GetEvent::new(self.inner.clone())
    }

    /// Creates a new Event in a 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::Event;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_event()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))
    ///         .set_event_id("event_id_value")
    ///         .set_event(
    ///             Event::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_event(&self) -> super::builder::streams_service::CreateEvent {
        super::builder::streams_service::CreateEvent::new(self.inner.clone())
    }

    /// Updates the parameters of a single Event.
    ///
    /// # 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Event;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str, event_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_event()
    ///         .set_event(
    ///             Event::new().set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/events/{event_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_event(&self) -> super::builder::streams_service::UpdateEvent {
        super::builder::streams_service::UpdateEvent::new(self.inner.clone())
    }

    /// Deletes a single Event.
    ///
    /// # 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str, event_id: &str
    /// ) -> Result<()> {
    ///     client.delete_event()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/events/{event_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_event(&self) -> super::builder::streams_service::DeleteEvent {
        super::builder::streams_service::DeleteEvent::new(self.inner.clone())
    }

    /// Lists Series in a given project and location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamsService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_series()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_series(&self) -> super::builder::streams_service::ListSeries {
        super::builder::streams_service::ListSeries::new(self.inner.clone())
    }

    /// Gets details of a single Series.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamsService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str, series_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_series()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/series/{series_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_series(&self) -> super::builder::streams_service::GetSeries {
        super::builder::streams_service::GetSeries::new(self.inner.clone())
    }

    /// Creates a new Series in a 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::Series;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_series()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"))
    ///         .set_series_id("series_id_value")
    ///         .set_series(
    ///             Series::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_series(&self) -> super::builder::streams_service::CreateSeries {
        super::builder::streams_service::CreateSeries::new(self.inner.clone())
    }

    /// Updates the parameters of a single Event.
    ///
    /// # 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Series;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str, series_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_series()
    ///         .set_series(
    ///             Series::new().set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/series/{series_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_series(&self) -> super::builder::streams_service::UpdateSeries {
        super::builder::streams_service::UpdateSeries::new(self.inner.clone())
    }

    /// Deletes a single Series.
    ///
    /// # 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService, project_id: &str, location_id: &str, cluster_id: &str, series_id: &str
    /// ) -> Result<()> {
    ///     client.delete_series()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}/series/{series_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_series(&self) -> super::builder::streams_service::DeleteSeries {
        super::builder::streams_service::DeleteSeries::new(self.inner.clone())
    }

    /// Materialize a channel.
    ///
    /// # 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_visionai_v1::client::StreamsService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService
    /// ) -> Result<()> {
    ///     let response = client.materialize_channel()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn materialize_channel(&self) -> super::builder::streams_service::MaterializeChannel {
        super::builder::streams_service::MaterializeChannel::new(self.inner.clone())
    }

    /// Lists information about the supported locations for this service.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamsService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService
    /// ) -> 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::streams_service::ListLocations {
        super::builder::streams_service::ListLocations::new(self.inner.clone())
    }

    /// Gets information about a location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::StreamsService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService
    /// ) -> Result<()> {
    ///     let response = client.get_location()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_location(&self) -> super::builder::streams_service::GetLocation {
        super::builder::streams_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_visionai_v1::client::StreamsService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService
    /// ) -> 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::streams_service::ListOperations {
        super::builder::streams_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_visionai_v1::client::StreamsService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::streams_service::GetOperation {
        super::builder::streams_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_visionai_v1::client::StreamsService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::streams_service::DeleteOperation {
        super::builder::streams_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_visionai_v1::client::StreamsService;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &StreamsService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::streams_service::CancelOperation {
        super::builder::streams_service::CancelOperation::new(self.inner.clone())
    }
}

/// Implements a client for the Vision AI API.
///
/// # Example
/// ```
/// # use google_cloud_visionai_v1::client::Warehouse;
/// use google_cloud_gax::paginator::ItemPaginator as _;
/// async fn sample(
///    project_number_id: &str,
///    location_id: &str,
///    corpus_id: &str,
/// ) -> anyhow::Result<()> {
///     let client = Warehouse::builder().build().await?;
///     let mut list = client.list_assets()
///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
///         .by_item();
///     while let Some(item) = list.next().await.transpose()? {
///         println!("{:?}", item);
///     }
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// Service that manages media content + metadata for streaming.
///
/// # Configuration
///
/// To configure `Warehouse` use the `with_*` methods in the type returned
/// by [builder()][Warehouse::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://visionai.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::warehouse::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::warehouse::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
///
/// `Warehouse` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `Warehouse` 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 Warehouse {
    inner: std::sync::Arc<dyn super::stub::dynamic::Warehouse>,
}

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

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

    /// Creates an asset inside corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::model::Asset;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_asset()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .set_asset_id("asset_id_value")
    ///         .set_asset(
    ///             Asset::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_asset(&self) -> super::builder::warehouse::CreateAsset {
        super::builder::warehouse::CreateAsset::new(self.inner.clone())
    }

    /// Updates an asset inside corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Asset;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, asset_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_asset()
    ///         .set_asset(
    ///             Asset::new().set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/assets/{asset_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_asset(&self) -> super::builder::warehouse::UpdateAsset {
        super::builder::warehouse::UpdateAsset::new(self.inner.clone())
    }

    /// Reads an asset inside corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, asset_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_asset()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/assets/{asset_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_asset(&self) -> super::builder::warehouse::GetAsset {
        super::builder::warehouse::GetAsset::new(self.inner.clone())
    }

    /// Lists an list of assets inside corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_assets()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_assets(&self) -> super::builder::warehouse::ListAssets {
        super::builder::warehouse::ListAssets::new(self.inner.clone())
    }

    /// Deletes asset inside corpus.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, asset_id: &str
    /// ) -> Result<()> {
    ///     client.delete_asset()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/assets/{asset_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_asset(&self) -> super::builder::warehouse::DeleteAsset {
        super::builder::warehouse::DeleteAsset::new(self.inner.clone())
    }

    /// Upload asset by specifing the asset Cloud Storage uri.
    /// For video warehouse, it requires users who call this API have read access
    /// to the cloud storage file. Once it is uploaded, it can be retrieved by
    /// GenerateRetrievalUrl API which by default, only can retrieve cloud storage
    /// files from the same project of the warehouse. To allow retrieval cloud
    /// storage files that are in a separate project, it requires to find the
    /// vision ai service account (Go to IAM, check checkbox to show "Include
    /// Google-provided role grants", search for "Cloud Vision AI Service Agent")
    /// and grant the read access of the cloud storage files to that service
    /// account.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.upload_asset()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn upload_asset(&self) -> super::builder::warehouse::UploadAsset {
        super::builder::warehouse::UploadAsset::new(self.inner.clone())
    }

    /// Generates a signed url for downloading the asset.
    /// For video warehouse, please see comment of UploadAsset about how to allow
    /// retrieval of cloud storage files in a different project.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.generate_retrieval_url()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn generate_retrieval_url(&self) -> super::builder::warehouse::GenerateRetrievalUrl {
        super::builder::warehouse::GenerateRetrievalUrl::new(self.inner.clone())
    }

    /// Analyze asset to power search capability.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.analyze_asset()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn analyze_asset(&self) -> super::builder::warehouse::AnalyzeAsset {
        super::builder::warehouse::AnalyzeAsset::new(self.inner.clone())
    }

    /// Index one asset for search.
    /// Supported corpus type: Corpus.Type.VIDEO_ON_DEMAND
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.index_asset()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn index_asset(&self) -> super::builder::warehouse::IndexAsset {
        super::builder::warehouse::IndexAsset::new(self.inner.clone())
    }

    /// Remove one asset's index data for search.
    /// Supported corpus type: Corpus.Type.VIDEO_ON_DEMAND
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.remove_index_asset()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn remove_index_asset(&self) -> super::builder::warehouse::RemoveIndexAsset {
        super::builder::warehouse::RemoveIndexAsset::new(self.inner.clone())
    }

    /// Lists assets inside an index.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let mut list = client.view_indexed_assets()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn view_indexed_assets(&self) -> super::builder::warehouse::ViewIndexedAssets {
        super::builder::warehouse::ViewIndexedAssets::new(self.inner.clone())
    }

    /// Creates an Index under the corpus.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::Index;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_index()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .set_index_id("index_id_value")
    ///         .set_index(
    ///             Index::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_index(&self) -> super::builder::warehouse::CreateIndex {
        super::builder::warehouse::CreateIndex::new(self.inner.clone())
    }

    /// Updates an Index under the corpus.
    /// Users can perform a metadata-only update or trigger a full index rebuild
    /// with different update_mask values.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Index;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, index_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_index()
    ///         .set_index(
    ///             Index::new().set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/indexes/{index_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_index(&self) -> super::builder::warehouse::UpdateIndex {
        super::builder::warehouse::UpdateIndex::new(self.inner.clone())
    }

    /// Gets the details of a single Index under a Corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, index_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_index()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/indexes/{index_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_index(&self) -> super::builder::warehouse::GetIndex {
        super::builder::warehouse::GetIndex::new(self.inner.clone())
    }

    /// List all Indexes in a given Corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_indexes()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_indexes(&self) -> super::builder::warehouse::ListIndexes {
        super::builder::warehouse::ListIndexes::new(self.inner.clone())
    }

    /// Delete a single Index. In order to delete an index, the caller must
    /// make sure that it is not deployed to any index endpoint.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, index_id: &str
    /// ) -> Result<()> {
    ///     client.delete_index()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/indexes/{index_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_index(&self) -> super::builder::warehouse::DeleteIndex {
        super::builder::warehouse::DeleteIndex::new(self.inner.clone())
    }

    /// Creates a corpus inside a project.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::Corpus;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_corpus()
    ///         .set_parent(parent)
    ///         .set_corpus(
    ///             Corpus::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_corpus(&self) -> super::builder::warehouse::CreateCorpus {
        super::builder::warehouse::CreateCorpus::new(self.inner.clone())
    }

    /// Gets corpus details inside a project.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_corpus()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_corpus(&self) -> super::builder::warehouse::GetCorpus {
        super::builder::warehouse::GetCorpus::new(self.inner.clone())
    }

    /// Updates a corpus in a project.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Corpus;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_corpus()
    ///         .set_corpus(
    ///             Corpus::new().set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_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_corpus(&self) -> super::builder::warehouse::UpdateCorpus {
        super::builder::warehouse::UpdateCorpus::new(self.inner.clone())
    }

    /// Lists all corpora in a project.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_corpora()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_corpora(&self) -> super::builder::warehouse::ListCorpora {
        super::builder::warehouse::ListCorpora::new(self.inner.clone())
    }

    /// Deletes a corpus only if its empty.
    /// Returns empty response.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     client.delete_corpus()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_corpus(&self) -> super::builder::warehouse::DeleteCorpus {
        super::builder::warehouse::DeleteCorpus::new(self.inner.clone())
    }

    /// Analyzes a corpus.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.analyze_corpus()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn analyze_corpus(&self) -> super::builder::warehouse::AnalyzeCorpus {
        super::builder::warehouse::AnalyzeCorpus::new(self.inner.clone())
    }

    /// Creates data schema inside corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::model::DataSchema;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_data_schema()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .set_data_schema(
    ///             DataSchema::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_data_schema(&self) -> super::builder::warehouse::CreateDataSchema {
        super::builder::warehouse::CreateDataSchema::new(self.inner.clone())
    }

    /// Updates data schema inside corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::DataSchema;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, data_schema_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_data_schema()
    ///         .set_data_schema(
    ///             DataSchema::new().set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/dataSchemas/{data_schema_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_data_schema(&self) -> super::builder::warehouse::UpdateDataSchema {
        super::builder::warehouse::UpdateDataSchema::new(self.inner.clone())
    }

    /// Gets data schema inside corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, data_schema_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_data_schema()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/dataSchemas/{data_schema_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_data_schema(&self) -> super::builder::warehouse::GetDataSchema {
        super::builder::warehouse::GetDataSchema::new(self.inner.clone())
    }

    /// Deletes data schema inside corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, data_schema_id: &str
    /// ) -> Result<()> {
    ///     client.delete_data_schema()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/dataSchemas/{data_schema_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_data_schema(&self) -> super::builder::warehouse::DeleteDataSchema {
        super::builder::warehouse::DeleteDataSchema::new(self.inner.clone())
    }

    /// Lists a list of data schemas inside corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_data_schemas()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_data_schemas(&self) -> super::builder::warehouse::ListDataSchemas {
        super::builder::warehouse::ListDataSchemas::new(self.inner.clone())
    }

    /// Creates annotation inside asset.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::model::Annotation;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, asset_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_annotation()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/assets/{asset_id}"))
    ///         .set_annotation_id("annotation_id_value")
    ///         .set_annotation(
    ///             Annotation::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_annotation(&self) -> super::builder::warehouse::CreateAnnotation {
        super::builder::warehouse::CreateAnnotation::new(self.inner.clone())
    }

    /// Reads annotation inside asset.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, asset_id: &str, annotation_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_annotation()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/assets/{asset_id}/annotations/{annotation_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_annotation(&self) -> super::builder::warehouse::GetAnnotation {
        super::builder::warehouse::GetAnnotation::new(self.inner.clone())
    }

    /// Lists a list of annotations inside asset.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, asset_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_annotations()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/assets/{asset_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_annotations(&self) -> super::builder::warehouse::ListAnnotations {
        super::builder::warehouse::ListAnnotations::new(self.inner.clone())
    }

    /// Updates annotation inside asset.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Annotation;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, asset_id: &str, annotation_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_annotation()
    ///         .set_annotation(
    ///             Annotation::new().set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/assets/{asset_id}/annotations/{annotation_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_annotation(&self) -> super::builder::warehouse::UpdateAnnotation {
        super::builder::warehouse::UpdateAnnotation::new(self.inner.clone())
    }

    /// Deletes annotation inside asset.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, asset_id: &str, annotation_id: &str
    /// ) -> Result<()> {
    ///     client.delete_annotation()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/assets/{asset_id}/annotations/{annotation_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_annotation(&self) -> super::builder::warehouse::DeleteAnnotation {
        super::builder::warehouse::DeleteAnnotation::new(self.inner.clone())
    }

    /// Supported by STREAM_VIDEO corpus type.
    /// Generates clips for downloading. The api takes in a time range, and
    /// generates a clip of the first content available after start_time and
    /// before end_time, which may overflow beyond these bounds.
    /// Returned clips are truncated if the total size of the clips are larger
    /// than 100MB.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.clip_asset()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn clip_asset(&self) -> super::builder::warehouse::ClipAsset {
        super::builder::warehouse::ClipAsset::new(self.inner.clone())
    }

    /// Generates a uri for an HLS manifest. The api takes in a collection of time
    /// ranges, and generates a URI for an HLS manifest that covers all the
    /// requested time ranges.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.generate_hls_uri()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn generate_hls_uri(&self) -> super::builder::warehouse::GenerateHlsUri {
        super::builder::warehouse::GenerateHlsUri::new(self.inner.clone())
    }

    /// Imports assets (images plus annotations) from a meta file on cloud storage.
    /// Each row in the meta file is corresponding to an image (specified by a
    /// cloud storage uri) and its annotations.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.import_assets()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn import_assets(&self) -> super::builder::warehouse::ImportAssets {
        super::builder::warehouse::ImportAssets::new(self.inner.clone())
    }

    /// Creates a search configuration inside a corpus.
    ///
    /// Please follow the rules below to create a valid CreateSearchConfigRequest.
    /// --- General Rules ---
    ///
    /// 1. Request.search_config_id must not be associated with an existing
    ///    SearchConfig.
    /// 1. Request must contain at least one non-empty search_criteria_property or
    ///    facet_property.
    /// 1. mapped_fields must not be empty, and must map to existing UGA keys.
    /// 1. All mapped_fields must be of the same type.
    /// 1. All mapped_fields must share the same granularity.
    /// 1. All mapped_fields must share the same semantic SearchConfig match
    ///    options.
    ///    For property-specific rules, please reference the comments for
    ///    FacetProperty and SearchCriteriaProperty.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::model::SearchConfig;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_search_config()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .set_search_config(
    ///             SearchConfig::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_search_config(&self) -> super::builder::warehouse::CreateSearchConfig {
        super::builder::warehouse::CreateSearchConfig::new(self.inner.clone())
    }

    /// Updates a search configuration inside a corpus.
    ///
    /// Please follow the rules below to create a valid UpdateSearchConfigRequest.
    /// --- General Rules ---
    ///
    /// 1. Request.search_configuration.name must already exist.
    /// 1. Request must contain at least one non-empty search_criteria_property or
    ///    facet_property.
    /// 1. mapped_fields must not be empty, and must map to existing UGA keys.
    /// 1. All mapped_fields must be of the same type.
    /// 1. All mapped_fields must share the same granularity.
    /// 1. All mapped_fields must share the same semantic SearchConfig match
    ///    options.
    ///    For property-specific rules, please reference the comments for
    ///    FacetProperty and SearchCriteriaProperty.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::SearchConfig;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, search_config_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_search_config()
    ///         .set_search_config(
    ///             SearchConfig::new().set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/searchConfigs/{search_config_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_search_config(&self) -> super::builder::warehouse::UpdateSearchConfig {
        super::builder::warehouse::UpdateSearchConfig::new(self.inner.clone())
    }

    /// Gets a search configuration inside a corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, search_config_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_search_config()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/searchConfigs/{search_config_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_search_config(&self) -> super::builder::warehouse::GetSearchConfig {
        super::builder::warehouse::GetSearchConfig::new(self.inner.clone())
    }

    /// Deletes a search configuration inside a corpus.
    ///
    /// For a DeleteSearchConfigRequest to be valid,
    /// Request.search_configuration.name must already exist.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, search_config_id: &str
    /// ) -> Result<()> {
    ///     client.delete_search_config()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/searchConfigs/{search_config_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_search_config(&self) -> super::builder::warehouse::DeleteSearchConfig {
        super::builder::warehouse::DeleteSearchConfig::new(self.inner.clone())
    }

    /// Lists all search configurations inside a corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_search_configs()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_search_configs(&self) -> super::builder::warehouse::ListSearchConfigs {
        super::builder::warehouse::ListSearchConfigs::new(self.inner.clone())
    }

    /// Creates a SearchHypernym inside a corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::model::SearchHypernym;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_search_hypernym()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .set_search_hypernym(
    ///             SearchHypernym::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_search_hypernym(&self) -> super::builder::warehouse::CreateSearchHypernym {
        super::builder::warehouse::CreateSearchHypernym::new(self.inner.clone())
    }

    /// Updates a SearchHypernym inside a corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::SearchHypernym;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, search_hypernym_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_search_hypernym()
    ///         .set_search_hypernym(
    ///             SearchHypernym::new().set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/searchHypernyms/{search_hypernym_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_search_hypernym(&self) -> super::builder::warehouse::UpdateSearchHypernym {
        super::builder::warehouse::UpdateSearchHypernym::new(self.inner.clone())
    }

    /// Gets a SearchHypernym inside a corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, search_hypernym_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_search_hypernym()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/searchHypernyms/{search_hypernym_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_search_hypernym(&self) -> super::builder::warehouse::GetSearchHypernym {
        super::builder::warehouse::GetSearchHypernym::new(self.inner.clone())
    }

    /// Deletes a SearchHypernym inside a corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, search_hypernym_id: &str
    /// ) -> Result<()> {
    ///     client.delete_search_hypernym()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/searchHypernyms/{search_hypernym_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_search_hypernym(&self) -> super::builder::warehouse::DeleteSearchHypernym {
        super::builder::warehouse::DeleteSearchHypernym::new(self.inner.clone())
    }

    /// Lists SearchHypernyms inside a corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_search_hypernyms()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_search_hypernyms(&self) -> super::builder::warehouse::ListSearchHypernyms {
        super::builder::warehouse::ListSearchHypernyms::new(self.inner.clone())
    }

    /// Search media asset.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let mut list = client.search_assets()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn search_assets(&self) -> super::builder::warehouse::SearchAssets {
        super::builder::warehouse::SearchAssets::new(self.inner.clone())
    }

    /// Search a deployed index endpoint (IMAGE corpus type only).
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let mut list = client.search_index_endpoint()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn search_index_endpoint(&self) -> super::builder::warehouse::SearchIndexEndpoint {
        super::builder::warehouse::SearchIndexEndpoint::new(self.inner.clone())
    }

    /// Creates an IndexEndpoint.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::IndexEndpoint;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_index_endpoint()
    ///         .set_parent(parent)
    ///         .set_index_endpoint(
    ///             IndexEndpoint::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_index_endpoint(&self) -> super::builder::warehouse::CreateIndexEndpoint {
        super::builder::warehouse::CreateIndexEndpoint::new(self.inner.clone())
    }

    /// Gets an IndexEndpoint.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_id: &str, location_id: &str, index_endpoint_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_index_endpoint()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/indexEndpoints/{index_endpoint_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_index_endpoint(&self) -> super::builder::warehouse::GetIndexEndpoint {
        super::builder::warehouse::GetIndexEndpoint::new(self.inner.clone())
    }

    /// Lists all IndexEndpoints in a project.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_index_endpoints()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_index_endpoints(&self) -> super::builder::warehouse::ListIndexEndpoints {
        super::builder::warehouse::ListIndexEndpoints::new(self.inner.clone())
    }

    /// Updates an IndexEndpoint.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::IndexEndpoint;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_id: &str, location_id: &str, index_endpoint_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_index_endpoint()
    ///         .set_index_endpoint(
    ///             IndexEndpoint::new().set_name(format!("projects/{project_id}/locations/{location_id}/indexEndpoints/{index_endpoint_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_index_endpoint(&self) -> super::builder::warehouse::UpdateIndexEndpoint {
        super::builder::warehouse::UpdateIndexEndpoint::new(self.inner.clone())
    }

    /// Deletes an IndexEndpoint.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_id: &str, location_id: &str, index_endpoint_id: &str
    /// ) -> Result<()> {
    ///     client.delete_index_endpoint()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/indexEndpoints/{index_endpoint_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_index_endpoint(&self) -> super::builder::warehouse::DeleteIndexEndpoint {
        super::builder::warehouse::DeleteIndexEndpoint::new(self.inner.clone())
    }

    /// Deploys an Index to IndexEndpoint.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.deploy_index()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn deploy_index(&self) -> super::builder::warehouse::DeployIndex {
        super::builder::warehouse::DeployIndex::new(self.inner.clone())
    }

    /// Undeploys an Index from IndexEndpoint.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.undeploy_index()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn undeploy_index(&self) -> super::builder::warehouse::UndeployIndex {
        super::builder::warehouse::UndeployIndex::new(self.inner.clone())
    }

    /// Creates a collection.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::model::Collection;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_collection()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .set_collection_id("collection_id_value")
    ///         .set_collection(
    ///             Collection::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_collection(&self) -> super::builder::warehouse::CreateCollection {
        super::builder::warehouse::CreateCollection::new(self.inner.clone())
    }

    /// Deletes a collection.
    ///
    /// # 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_visionai_v1::client::Warehouse;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, collection_id: &str
    /// ) -> Result<()> {
    ///     client.delete_collection()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/collections/{collection_id}"))
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_collection(&self) -> super::builder::warehouse::DeleteCollection {
        super::builder::warehouse::DeleteCollection::new(self.inner.clone())
    }

    /// Gets a collection.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, collection_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_collection()
    ///         .set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/collections/{collection_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_collection(&self) -> super::builder::warehouse::GetCollection {
        super::builder::warehouse::GetCollection::new(self.inner.clone())
    }

    /// Updates a collection.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_visionai_v1::model::Collection;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str, collection_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_collection()
    ///         .set_collection(
    ///             Collection::new().set_name(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}/collections/{collection_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_collection(&self) -> super::builder::warehouse::UpdateCollection {
        super::builder::warehouse::UpdateCollection::new(self.inner.clone())
    }

    /// Lists collections inside a corpus.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse, project_number_id: &str, location_id: &str, corpus_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_collections()
    ///         .set_parent(format!("projects/{project_number_id}/locations/{location_id}/corpora/{corpus_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_collections(&self) -> super::builder::warehouse::ListCollections {
        super::builder::warehouse::ListCollections::new(self.inner.clone())
    }

    /// Adds an item into a Collection.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.add_collection_item()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn add_collection_item(&self) -> super::builder::warehouse::AddCollectionItem {
        super::builder::warehouse::AddCollectionItem::new(self.inner.clone())
    }

    /// Removes an item from a collection.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.remove_collection_item()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn remove_collection_item(&self) -> super::builder::warehouse::RemoveCollectionItem {
        super::builder::warehouse::RemoveCollectionItem::new(self.inner.clone())
    }

    /// View items inside a collection.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let mut list = client.view_collection_items()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn view_collection_items(&self) -> super::builder::warehouse::ViewCollectionItems {
        super::builder::warehouse::ViewCollectionItems::new(self.inner.clone())
    }

    /// Lists information about the supported locations for this service.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> 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::warehouse::ListLocations {
        super::builder::warehouse::ListLocations::new(self.inner.clone())
    }

    /// Gets information about a location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.get_location()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_location(&self) -> super::builder::warehouse::GetLocation {
        super::builder::warehouse::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_visionai_v1::client::Warehouse;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> 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::warehouse::ListOperations {
        super::builder::warehouse::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_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::warehouse::GetOperation {
        super::builder::warehouse::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_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::warehouse::DeleteOperation {
        super::builder::warehouse::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_visionai_v1::client::Warehouse;
    /// use google_cloud_visionai_v1::Result;
    /// async fn sample(
    ///    client: &Warehouse
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::warehouse::CancelOperation {
        super::builder::warehouse::CancelOperation::new(self.inner.clone())
    }
}