google_cloud_chronicle_v1/

client.rs

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

/// Implements a client for the Chronicle API.
///
/// # Example
/// ```
/// # use google_cloud_chronicle_v1::client::BigQueryExportService;
/// async fn sample(
///    project_id: &str,
///    location_id: &str,
///    instance_id: &str,
/// ) -> anyhow::Result<()> {
///     let client = BigQueryExportService::builder().build().await?;
///     let response = client.get_big_query_export()
///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/bigQueryExport"))
///         .send().await?;
///     println!("response {:?}", response);
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// Service for managing BigQuery export configurations for Chronicle instances.
///
/// # Configuration
///
/// To configure `BigQueryExportService` use the `with_*` methods in the type returned
/// by [builder()][BigQueryExportService::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://chronicle.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::big_query_export_service::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::big_query_export_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
///
/// `BigQueryExportService` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `BigQueryExportService` 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 BigQueryExportService {
    inner: std::sync::Arc<dyn super::stub::dynamic::BigQueryExportService>,
}

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

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

    /// Get the BigQuery export configuration for a Chronicle instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::BigQueryExportService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &BigQueryExportService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_big_query_export()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/bigQueryExport"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_big_query_export(
        &self,
    ) -> super::builder::big_query_export_service::GetBigQueryExport {
        super::builder::big_query_export_service::GetBigQueryExport::new(self.inner.clone())
    }

    /// Update the BigQuery export configuration for a Chronicle instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::BigQueryExportService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_chronicle_v1::model::BigQueryExport;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &BigQueryExportService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_big_query_export()
    ///         .set_big_query_export(
    ///             BigQueryExport::new().set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/bigQueryExport"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_big_query_export(
        &self,
    ) -> super::builder::big_query_export_service::UpdateBigQueryExport {
        super::builder::big_query_export_service::UpdateBigQueryExport::new(self.inner.clone())
    }

    /// Provision the BigQuery export for a Chronicle instance. This will create
    /// {{gcp_name}} resources like {{storage_name}} buckets, BigQuery datasets
    /// and set default export settings for each data source.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::BigQueryExportService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &BigQueryExportService
    /// ) -> Result<()> {
    ///     let response = client.provision_big_query_export()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn provision_big_query_export(
        &self,
    ) -> super::builder::big_query_export_service::ProvisionBigQueryExport {
        super::builder::big_query_export_service::ProvisionBigQueryExport::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_chronicle_v1::client::BigQueryExportService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &BigQueryExportService
    /// ) -> 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::big_query_export_service::ListOperations {
        super::builder::big_query_export_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_chronicle_v1::client::BigQueryExportService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &BigQueryExportService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::big_query_export_service::GetOperation {
        super::builder::big_query_export_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_chronicle_v1::client::BigQueryExportService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &BigQueryExportService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::big_query_export_service::DeleteOperation {
        super::builder::big_query_export_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_chronicle_v1::client::BigQueryExportService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &BigQueryExportService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::big_query_export_service::CancelOperation {
        super::builder::big_query_export_service::CancelOperation::new(self.inner.clone())
    }
}

/// Implements a client for the Chronicle API.
///
/// # Example
/// ```
/// # use google_cloud_chronicle_v1::client::DashboardChartService;
/// async fn sample(
///    project_id: &str,
///    location_id: &str,
///    instance_id: &str,
///    chart_id: &str,
/// ) -> anyhow::Result<()> {
///     let client = DashboardChartService::builder().build().await?;
///     let response = client.get_dashboard_chart()
///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dashboardCharts/{chart_id}"))
///         .send().await?;
///     println!("response {:?}", response);
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// A service providing functionality for managing dashboards' charts.
///
/// # Configuration
///
/// To configure `DashboardChartService` use the `with_*` methods in the type returned
/// by [builder()][DashboardChartService::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://chronicle.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::dashboard_chart_service::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::dashboard_chart_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
///
/// `DashboardChartService` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `DashboardChartService` 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 DashboardChartService {
    inner: std::sync::Arc<dyn super::stub::dynamic::DashboardChartService>,
}

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

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

    /// Get a dashboard chart.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DashboardChartService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DashboardChartService, project_id: &str, location_id: &str, instance_id: &str, chart_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_dashboard_chart()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dashboardCharts/{chart_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_dashboard_chart(
        &self,
    ) -> super::builder::dashboard_chart_service::GetDashboardChart {
        super::builder::dashboard_chart_service::GetDashboardChart::new(self.inner.clone())
    }

    /// Get dashboard charts in batches.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DashboardChartService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DashboardChartService
    /// ) -> Result<()> {
    ///     let response = client.batch_get_dashboard_charts()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn batch_get_dashboard_charts(
        &self,
    ) -> super::builder::dashboard_chart_service::BatchGetDashboardCharts {
        super::builder::dashboard_chart_service::BatchGetDashboardCharts::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_chronicle_v1::client::DashboardChartService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DashboardChartService
    /// ) -> 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::dashboard_chart_service::ListOperations {
        super::builder::dashboard_chart_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_chronicle_v1::client::DashboardChartService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DashboardChartService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::dashboard_chart_service::GetOperation {
        super::builder::dashboard_chart_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_chronicle_v1::client::DashboardChartService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DashboardChartService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::dashboard_chart_service::DeleteOperation {
        super::builder::dashboard_chart_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_chronicle_v1::client::DashboardChartService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DashboardChartService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::dashboard_chart_service::CancelOperation {
        super::builder::dashboard_chart_service::CancelOperation::new(self.inner.clone())
    }
}

/// Implements a client for the Chronicle API.
///
/// # Example
/// ```
/// # use google_cloud_chronicle_v1::client::DashboardQueryService;
/// async fn sample(
///    project_id: &str,
///    location_id: &str,
///    instance_id: &str,
///    query_id: &str,
/// ) -> anyhow::Result<()> {
///     let client = DashboardQueryService::builder().build().await?;
///     let response = client.get_dashboard_query()
///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dashboardQueries/{query_id}"))
///         .send().await?;
///     println!("response {:?}", response);
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// A service providing functionality for managing dashboards' queries.
///
/// # Configuration
///
/// To configure `DashboardQueryService` use the `with_*` methods in the type returned
/// by [builder()][DashboardQueryService::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://chronicle.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::dashboard_query_service::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::dashboard_query_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
///
/// `DashboardQueryService` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `DashboardQueryService` 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 DashboardQueryService {
    inner: std::sync::Arc<dyn super::stub::dynamic::DashboardQueryService>,
}

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

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

    /// Get a dashboard query.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DashboardQueryService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DashboardQueryService, project_id: &str, location_id: &str, instance_id: &str, query_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_dashboard_query()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dashboardQueries/{query_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_dashboard_query(
        &self,
    ) -> super::builder::dashboard_query_service::GetDashboardQuery {
        super::builder::dashboard_query_service::GetDashboardQuery::new(self.inner.clone())
    }

    /// Execute a query and return the data.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DashboardQueryService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DashboardQueryService
    /// ) -> Result<()> {
    ///     let response = client.execute_dashboard_query()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn execute_dashboard_query(
        &self,
    ) -> super::builder::dashboard_query_service::ExecuteDashboardQuery {
        super::builder::dashboard_query_service::ExecuteDashboardQuery::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_chronicle_v1::client::DashboardQueryService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DashboardQueryService
    /// ) -> 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::dashboard_query_service::ListOperations {
        super::builder::dashboard_query_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_chronicle_v1::client::DashboardQueryService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DashboardQueryService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::dashboard_query_service::GetOperation {
        super::builder::dashboard_query_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_chronicle_v1::client::DashboardQueryService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DashboardQueryService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::dashboard_query_service::DeleteOperation {
        super::builder::dashboard_query_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_chronicle_v1::client::DashboardQueryService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DashboardQueryService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::dashboard_query_service::CancelOperation {
        super::builder::dashboard_query_service::CancelOperation::new(self.inner.clone())
    }
}

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

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

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

    /// Creates a data access label.
    /// Data access labels are applied to incoming event data and selected in data
    /// access scopes (another resource), and only users with scopes containing the
    /// label can see data with that label. Currently, the data access label
    /// resource only includes custom labels, which are labels that correspond
    /// to UDM queries over event data.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataAccessControlService;
    /// use google_cloud_chronicle_v1::model::DataAccessLabel;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_data_access_label()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .set_data_access_label(
    ///             DataAccessLabel::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_data_access_label(
        &self,
    ) -> super::builder::data_access_control_service::CreateDataAccessLabel {
        super::builder::data_access_control_service::CreateDataAccessLabel::new(self.inner.clone())
    }

    /// Gets a data access label.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataAccessControlService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService, project_id: &str, location_id: &str, instance_id: &str, data_access_label_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_data_access_label()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataAccessLabels/{data_access_label_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_data_access_label(
        &self,
    ) -> super::builder::data_access_control_service::GetDataAccessLabel {
        super::builder::data_access_control_service::GetDataAccessLabel::new(self.inner.clone())
    }

    /// Lists all data access labels for the customer.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataAccessControlService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_data_access_labels()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_data_access_labels(
        &self,
    ) -> super::builder::data_access_control_service::ListDataAccessLabels {
        super::builder::data_access_control_service::ListDataAccessLabels::new(self.inner.clone())
    }

    /// Updates a data access label.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataAccessControlService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_chronicle_v1::model::DataAccessLabel;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService, project_id: &str, location_id: &str, instance_id: &str, data_access_label_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_data_access_label()
    ///         .set_data_access_label(
    ///             DataAccessLabel::new().set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataAccessLabels/{data_access_label_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_access_label(
        &self,
    ) -> super::builder::data_access_control_service::UpdateDataAccessLabel {
        super::builder::data_access_control_service::UpdateDataAccessLabel::new(self.inner.clone())
    }

    /// Deletes a data access label. When a label is deleted, new
    /// data that enters in the system will not receive the label, but the label
    /// will not be removed from old data that still refers to it.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataAccessControlService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService, project_id: &str, location_id: &str, instance_id: &str, data_access_label_id: &str
    /// ) -> Result<()> {
    ///     client.delete_data_access_label()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataAccessLabels/{data_access_label_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_data_access_label(
        &self,
    ) -> super::builder::data_access_control_service::DeleteDataAccessLabel {
        super::builder::data_access_control_service::DeleteDataAccessLabel::new(self.inner.clone())
    }

    /// Creates a data access scope.
    /// Data access scope is a combination of allowed and denied labels attached
    /// to a permission group. If a scope has allowed labels A and B and denied
    /// labels C and D, then the group of people attached to the scope
    /// will have permissions to see all events labeled with A or B (or both) and
    /// not labeled with either C or D.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataAccessControlService;
    /// use google_cloud_chronicle_v1::model::DataAccessScope;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_data_access_scope()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .set_data_access_scope(
    ///             DataAccessScope::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_data_access_scope(
        &self,
    ) -> super::builder::data_access_control_service::CreateDataAccessScope {
        super::builder::data_access_control_service::CreateDataAccessScope::new(self.inner.clone())
    }

    /// Retrieves an existing data access scope.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataAccessControlService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService, project_id: &str, location_id: &str, instance_id: &str, data_access_scope_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_data_access_scope()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataAccessScopes/{data_access_scope_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_data_access_scope(
        &self,
    ) -> super::builder::data_access_control_service::GetDataAccessScope {
        super::builder::data_access_control_service::GetDataAccessScope::new(self.inner.clone())
    }

    /// Lists all existing data access scopes for the customer.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataAccessControlService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_data_access_scopes()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_data_access_scopes(
        &self,
    ) -> super::builder::data_access_control_service::ListDataAccessScopes {
        super::builder::data_access_control_service::ListDataAccessScopes::new(self.inner.clone())
    }

    /// Updates a data access scope.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataAccessControlService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_chronicle_v1::model::DataAccessScope;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService, project_id: &str, location_id: &str, instance_id: &str, data_access_scope_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_data_access_scope()
    ///         .set_data_access_scope(
    ///             DataAccessScope::new().set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataAccessScopes/{data_access_scope_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_access_scope(
        &self,
    ) -> super::builder::data_access_control_service::UpdateDataAccessScope {
        super::builder::data_access_control_service::UpdateDataAccessScope::new(self.inner.clone())
    }

    /// Deletes a data access scope.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataAccessControlService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService, project_id: &str, location_id: &str, instance_id: &str, data_access_scope_id: &str
    /// ) -> Result<()> {
    ///     client.delete_data_access_scope()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataAccessScopes/{data_access_scope_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_data_access_scope(
        &self,
    ) -> super::builder::data_access_control_service::DeleteDataAccessScope {
        super::builder::data_access_control_service::DeleteDataAccessScope::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_chronicle_v1::client::DataAccessControlService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService
    /// ) -> 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::data_access_control_service::ListOperations {
        super::builder::data_access_control_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_chronicle_v1::client::DataAccessControlService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::data_access_control_service::GetOperation {
        super::builder::data_access_control_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_chronicle_v1::client::DataAccessControlService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::data_access_control_service::DeleteOperation {
        super::builder::data_access_control_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_chronicle_v1::client::DataAccessControlService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataAccessControlService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::data_access_control_service::CancelOperation {
        super::builder::data_access_control_service::CancelOperation::new(self.inner.clone())
    }
}

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

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

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

    /// Create a new data table.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::model::DataTable;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_data_table()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .set_data_table(
    ///             DataTable::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_data_table(&self) -> super::builder::data_table_service::CreateDataTable {
        super::builder::data_table_service::CreateDataTable::new(self.inner.clone())
    }

    /// List data tables.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_data_tables()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_data_tables(&self) -> super::builder::data_table_service::ListDataTables {
        super::builder::data_table_service::ListDataTables::new(self.inner.clone())
    }

    /// Get data table info.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService, project_id: &str, location_id: &str, instance_id: &str, data_table_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_data_table()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataTables/{data_table_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_data_table(&self) -> super::builder::data_table_service::GetDataTable {
        super::builder::data_table_service::GetDataTable::new(self.inner.clone())
    }

    /// Update data table.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_chronicle_v1::model::DataTable;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService, project_id: &str, location_id: &str, instance_id: &str, data_table_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_data_table()
    ///         .set_data_table(
    ///             DataTable::new().set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataTables/{data_table_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_table(&self) -> super::builder::data_table_service::UpdateDataTable {
        super::builder::data_table_service::UpdateDataTable::new(self.inner.clone())
    }

    /// Delete data table.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService, project_id: &str, location_id: &str, instance_id: &str, data_table_id: &str
    /// ) -> Result<()> {
    ///     client.delete_data_table()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataTables/{data_table_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_data_table(&self) -> super::builder::data_table_service::DeleteDataTable {
        super::builder::data_table_service::DeleteDataTable::new(self.inner.clone())
    }

    /// Create a new data table row.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::model::DataTableRow;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService, project_id: &str, location_id: &str, instance_id: &str, data_table_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_data_table_row()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataTables/{data_table_id}"))
    ///         .set_data_table_row(
    ///             DataTableRow::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_data_table_row(&self) -> super::builder::data_table_service::CreateDataTableRow {
        super::builder::data_table_service::CreateDataTableRow::new(self.inner.clone())
    }

    /// Update data table row
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_chronicle_v1::model::DataTableRow;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService, project_id: &str, location_id: &str, instance_id: &str, data_table_id: &str, data_table_row_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_data_table_row()
    ///         .set_data_table_row(
    ///             DataTableRow::new().set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataTables/{data_table_id}/dataTableRows/{data_table_row_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_table_row(&self) -> super::builder::data_table_service::UpdateDataTableRow {
        super::builder::data_table_service::UpdateDataTableRow::new(self.inner.clone())
    }

    /// List data table rows.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService, project_id: &str, location_id: &str, instance_id: &str, data_table_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_data_table_rows()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataTables/{data_table_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_data_table_rows(&self) -> super::builder::data_table_service::ListDataTableRows {
        super::builder::data_table_service::ListDataTableRows::new(self.inner.clone())
    }

    /// Get data table row
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService, project_id: &str, location_id: &str, instance_id: &str, data_table_id: &str, data_table_row_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_data_table_row()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataTables/{data_table_id}/dataTableRows/{data_table_row_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_data_table_row(&self) -> super::builder::data_table_service::GetDataTableRow {
        super::builder::data_table_service::GetDataTableRow::new(self.inner.clone())
    }

    /// Delete data table row.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService, project_id: &str, location_id: &str, instance_id: &str, data_table_id: &str, data_table_row_id: &str
    /// ) -> Result<()> {
    ///     client.delete_data_table_row()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataTables/{data_table_id}/dataTableRows/{data_table_row_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_data_table_row(&self) -> super::builder::data_table_service::DeleteDataTableRow {
        super::builder::data_table_service::DeleteDataTableRow::new(self.inner.clone())
    }

    /// Create data table rows in bulk.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService
    /// ) -> Result<()> {
    ///     let response = client.bulk_create_data_table_rows()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn bulk_create_data_table_rows(
        &self,
    ) -> super::builder::data_table_service::BulkCreateDataTableRows {
        super::builder::data_table_service::BulkCreateDataTableRows::new(self.inner.clone())
    }

    /// Get data table rows in bulk.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService
    /// ) -> Result<()> {
    ///     let response = client.bulk_get_data_table_rows()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn bulk_get_data_table_rows(
        &self,
    ) -> super::builder::data_table_service::BulkGetDataTableRows {
        super::builder::data_table_service::BulkGetDataTableRows::new(self.inner.clone())
    }

    /// Replace all existing data table rows with new data table rows.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService
    /// ) -> Result<()> {
    ///     let response = client.bulk_replace_data_table_rows()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn bulk_replace_data_table_rows(
        &self,
    ) -> super::builder::data_table_service::BulkReplaceDataTableRows {
        super::builder::data_table_service::BulkReplaceDataTableRows::new(self.inner.clone())
    }

    /// Update data table rows in bulk.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService
    /// ) -> Result<()> {
    ///     let response = client.bulk_update_data_table_rows()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn bulk_update_data_table_rows(
        &self,
    ) -> super::builder::data_table_service::BulkUpdateDataTableRows {
        super::builder::data_table_service::BulkUpdateDataTableRows::new(self.inner.clone())
    }

    /// Get the error for a data table operation.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService, project_id: &str, location_id: &str, instance_id: &str, data_table_operation_errors_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_data_table_operation_errors()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/dataTableOperationErrors/{data_table_operation_errors_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_data_table_operation_errors(
        &self,
    ) -> super::builder::data_table_service::GetDataTableOperationErrors {
        super::builder::data_table_service::GetDataTableOperationErrors::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_chronicle_v1::client::DataTableService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService
    /// ) -> 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::data_table_service::ListOperations {
        super::builder::data_table_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_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::data_table_service::GetOperation {
        super::builder::data_table_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_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::data_table_service::DeleteOperation {
        super::builder::data_table_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_chronicle_v1::client::DataTableService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &DataTableService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::data_table_service::CancelOperation {
        super::builder::data_table_service::CancelOperation::new(self.inner.clone())
    }
}

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

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

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

    /// Gets watchlist details for the given watchlist ID.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::EntityService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &EntityService, project_id: &str, location_id: &str, instance_id: &str, watchlist_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_watchlist()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/watchlists/{watchlist_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_watchlist(&self) -> super::builder::entity_service::GetWatchlist {
        super::builder::entity_service::GetWatchlist::new(self.inner.clone())
    }

    /// Lists all watchlists for the given instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::EntityService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &EntityService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_watchlists()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_watchlists(&self) -> super::builder::entity_service::ListWatchlists {
        super::builder::entity_service::ListWatchlists::new(self.inner.clone())
    }

    /// Creates a watchlist for the given instance.
    /// Note that there can be at most 200 watchlists per instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::EntityService;
    /// use google_cloud_chronicle_v1::model::Watchlist;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &EntityService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_watchlist()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .set_watchlist_id("watchlist_id_value")
    ///         .set_watchlist(
    ///             Watchlist::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_watchlist(&self) -> super::builder::entity_service::CreateWatchlist {
        super::builder::entity_service::CreateWatchlist::new(self.inner.clone())
    }

    /// Updates the watchlist for the given instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::EntityService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_chronicle_v1::model::Watchlist;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &EntityService, project_id: &str, location_id: &str, instance_id: &str, watchlist_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_watchlist()
    ///         .set_watchlist(
    ///             Watchlist::new().set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/watchlists/{watchlist_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_watchlist(&self) -> super::builder::entity_service::UpdateWatchlist {
        super::builder::entity_service::UpdateWatchlist::new(self.inner.clone())
    }

    /// Deletes the watchlist for the given instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::EntityService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &EntityService, project_id: &str, location_id: &str, instance_id: &str, watchlist_id: &str
    /// ) -> Result<()> {
    ///     client.delete_watchlist()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/watchlists/{watchlist_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_watchlist(&self) -> super::builder::entity_service::DeleteWatchlist {
        super::builder::entity_service::DeleteWatchlist::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_chronicle_v1::client::EntityService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &EntityService
    /// ) -> 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::entity_service::ListOperations {
        super::builder::entity_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_chronicle_v1::client::EntityService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &EntityService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::entity_service::GetOperation {
        super::builder::entity_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_chronicle_v1::client::EntityService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &EntityService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::entity_service::DeleteOperation {
        super::builder::entity_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_chronicle_v1::client::EntityService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &EntityService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::entity_service::CancelOperation {
        super::builder::entity_service::CancelOperation::new(self.inner.clone())
    }
}

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

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

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

    /// Get a native dashboard featured content.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::FeaturedContentNativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &FeaturedContentNativeDashboardService, project_id: &str, location_id: &str, instance_id: &str, featured_content_native_dashboard_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_featured_content_native_dashboard()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/contentHub/featuredContentNativeDashboards/{featured_content_native_dashboard_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_featured_content_native_dashboard(
        &self,
    ) -> super::builder::featured_content_native_dashboard_service::GetFeaturedContentNativeDashboard
    {
        super::builder::featured_content_native_dashboard_service::GetFeaturedContentNativeDashboard::new(self.inner.clone())
    }

    /// List all native dashboards featured content.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::FeaturedContentNativeDashboardService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &FeaturedContentNativeDashboardService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_featured_content_native_dashboards()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/contentHub"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_featured_content_native_dashboards(&self) -> super::builder::featured_content_native_dashboard_service::ListFeaturedContentNativeDashboards
    {
        super::builder::featured_content_native_dashboard_service::ListFeaturedContentNativeDashboards::new(self.inner.clone())
    }

    /// Install a native dashboard featured content.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::FeaturedContentNativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &FeaturedContentNativeDashboardService
    /// ) -> Result<()> {
    ///     let response = client.install_featured_content_native_dashboard()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn install_featured_content_native_dashboard(&self) -> super::builder::featured_content_native_dashboard_service::InstallFeaturedContentNativeDashboard
    {
        super::builder::featured_content_native_dashboard_service::InstallFeaturedContentNativeDashboard::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_chronicle_v1::client::FeaturedContentNativeDashboardService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &FeaturedContentNativeDashboardService
    /// ) -> 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::featured_content_native_dashboard_service::ListOperations {
        super::builder::featured_content_native_dashboard_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_chronicle_v1::client::FeaturedContentNativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &FeaturedContentNativeDashboardService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(
        &self,
    ) -> super::builder::featured_content_native_dashboard_service::GetOperation {
        super::builder::featured_content_native_dashboard_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_chronicle_v1::client::FeaturedContentNativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &FeaturedContentNativeDashboardService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(
        &self,
    ) -> super::builder::featured_content_native_dashboard_service::DeleteOperation {
        super::builder::featured_content_native_dashboard_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_chronicle_v1::client::FeaturedContentNativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &FeaturedContentNativeDashboardService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(
        &self,
    ) -> super::builder::featured_content_native_dashboard_service::CancelOperation {
        super::builder::featured_content_native_dashboard_service::CancelOperation::new(
            self.inner.clone(),
        )
    }
}

/// Implements a client for the Chronicle API.
///
/// # Example
/// ```
/// # use google_cloud_chronicle_v1::client::InstanceService;
/// async fn sample(
///    project_id: &str,
///    location_id: &str,
///    instance_id: &str,
/// ) -> anyhow::Result<()> {
///     let client = InstanceService::builder().build().await?;
///     let response = client.get_instance()
///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
///         .send().await?;
///     println!("response {:?}", response);
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// InstanceService provides the entry interface for the Chronicle API.
///
/// # Configuration
///
/// To configure `InstanceService` use the `with_*` methods in the type returned
/// by [builder()][InstanceService::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://chronicle.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::instance_service::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::instance_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
///
/// `InstanceService` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `InstanceService` 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 InstanceService {
    inner: std::sync::Arc<dyn super::stub::dynamic::InstanceService>,
}

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

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

    /// Gets a Instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::InstanceService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &InstanceService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_instance()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_instance(&self) -> super::builder::instance_service::GetInstance {
        super::builder::instance_service::GetInstance::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_chronicle_v1::client::InstanceService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &InstanceService
    /// ) -> 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::instance_service::ListOperations {
        super::builder::instance_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_chronicle_v1::client::InstanceService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &InstanceService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::instance_service::GetOperation {
        super::builder::instance_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_chronicle_v1::client::InstanceService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &InstanceService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::instance_service::DeleteOperation {
        super::builder::instance_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_chronicle_v1::client::InstanceService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &InstanceService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::instance_service::CancelOperation {
        super::builder::instance_service::CancelOperation::new(self.inner.clone())
    }
}

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

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

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

    /// Create a dashboard.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_chronicle_v1::model::NativeDashboard;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_native_dashboard()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .set_native_dashboard(
    ///             NativeDashboard::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_native_dashboard(
        &self,
    ) -> super::builder::native_dashboard_service::CreateNativeDashboard {
        super::builder::native_dashboard_service::CreateNativeDashboard::new(self.inner.clone())
    }

    /// Get a dashboard.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService, project_id: &str, location_id: &str, instance_id: &str, dashboard_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_native_dashboard()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/nativeDashboards/{dashboard_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_native_dashboard(
        &self,
    ) -> super::builder::native_dashboard_service::GetNativeDashboard {
        super::builder::native_dashboard_service::GetNativeDashboard::new(self.inner.clone())
    }

    /// List all dashboards.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_native_dashboards()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_native_dashboards(
        &self,
    ) -> super::builder::native_dashboard_service::ListNativeDashboards {
        super::builder::native_dashboard_service::ListNativeDashboards::new(self.inner.clone())
    }

    /// Update a dashboard.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::NativeDashboardService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_chronicle_v1::model::NativeDashboard;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService, project_id: &str, location_id: &str, instance_id: &str, dashboard_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_native_dashboard()
    ///         .set_native_dashboard(
    ///             NativeDashboard::new().set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/nativeDashboards/{dashboard_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_native_dashboard(
        &self,
    ) -> super::builder::native_dashboard_service::UpdateNativeDashboard {
        super::builder::native_dashboard_service::UpdateNativeDashboard::new(self.inner.clone())
    }

    /// Duplicate a dashboard.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService
    /// ) -> Result<()> {
    ///     let response = client.duplicate_native_dashboard()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn duplicate_native_dashboard(
        &self,
    ) -> super::builder::native_dashboard_service::DuplicateNativeDashboard {
        super::builder::native_dashboard_service::DuplicateNativeDashboard::new(self.inner.clone())
    }

    /// Delete a dashboard.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService, project_id: &str, location_id: &str, instance_id: &str, dashboard_id: &str
    /// ) -> Result<()> {
    ///     client.delete_native_dashboard()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/nativeDashboards/{dashboard_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_native_dashboard(
        &self,
    ) -> super::builder::native_dashboard_service::DeleteNativeDashboard {
        super::builder::native_dashboard_service::DeleteNativeDashboard::new(self.inner.clone())
    }

    /// Add chart in a dashboard.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService
    /// ) -> Result<()> {
    ///     let response = client.add_chart()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn add_chart(&self) -> super::builder::native_dashboard_service::AddChart {
        super::builder::native_dashboard_service::AddChart::new(self.inner.clone())
    }

    /// Remove chart from a dashboard.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService
    /// ) -> Result<()> {
    ///     let response = client.remove_chart()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn remove_chart(&self) -> super::builder::native_dashboard_service::RemoveChart {
        super::builder::native_dashboard_service::RemoveChart::new(self.inner.clone())
    }

    /// Edit chart in a dashboard.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService
    /// ) -> Result<()> {
    ///     let response = client.edit_chart()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn edit_chart(&self) -> super::builder::native_dashboard_service::EditChart {
        super::builder::native_dashboard_service::EditChart::new(self.inner.clone())
    }

    /// Duplicate chart in a dashboard.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService
    /// ) -> Result<()> {
    ///     let response = client.duplicate_chart()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn duplicate_chart(&self) -> super::builder::native_dashboard_service::DuplicateChart {
        super::builder::native_dashboard_service::DuplicateChart::new(self.inner.clone())
    }

    /// Exports the dashboards.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService
    /// ) -> Result<()> {
    ///     let response = client.export_native_dashboards()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn export_native_dashboards(
        &self,
    ) -> super::builder::native_dashboard_service::ExportNativeDashboards {
        super::builder::native_dashboard_service::ExportNativeDashboards::new(self.inner.clone())
    }

    /// Imports the dashboards.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService
    /// ) -> Result<()> {
    ///     let response = client.import_native_dashboards()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn import_native_dashboards(
        &self,
    ) -> super::builder::native_dashboard_service::ImportNativeDashboards {
        super::builder::native_dashboard_service::ImportNativeDashboards::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_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService
    /// ) -> 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::native_dashboard_service::ListOperations {
        super::builder::native_dashboard_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_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::native_dashboard_service::GetOperation {
        super::builder::native_dashboard_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_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::native_dashboard_service::DeleteOperation {
        super::builder::native_dashboard_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_chronicle_v1::client::NativeDashboardService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &NativeDashboardService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::native_dashboard_service::CancelOperation {
        super::builder::native_dashboard_service::CancelOperation::new(self.inner.clone())
    }
}

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

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

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

    /// Gets a single reference list.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::ReferenceListService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &ReferenceListService, project_id: &str, location_id: &str, instance_id: &str, reference_list_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_reference_list()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/referenceLists/{reference_list_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_reference_list(&self) -> super::builder::reference_list_service::GetReferenceList {
        super::builder::reference_list_service::GetReferenceList::new(self.inner.clone())
    }

    /// Lists a collection of reference lists.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::ReferenceListService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &ReferenceListService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_reference_lists()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_reference_lists(
        &self,
    ) -> super::builder::reference_list_service::ListReferenceLists {
        super::builder::reference_list_service::ListReferenceLists::new(self.inner.clone())
    }

    /// Creates a new reference list.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::ReferenceListService;
    /// use google_cloud_chronicle_v1::model::ReferenceList;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &ReferenceListService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_reference_list()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .set_reference_list(
    ///             ReferenceList::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_reference_list(
        &self,
    ) -> super::builder::reference_list_service::CreateReferenceList {
        super::builder::reference_list_service::CreateReferenceList::new(self.inner.clone())
    }

    /// Updates an existing reference list.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::ReferenceListService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_chronicle_v1::model::ReferenceList;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &ReferenceListService, project_id: &str, location_id: &str, instance_id: &str, reference_list_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_reference_list()
    ///         .set_reference_list(
    ///             ReferenceList::new().set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/referenceLists/{reference_list_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_reference_list(
        &self,
    ) -> super::builder::reference_list_service::UpdateReferenceList {
        super::builder::reference_list_service::UpdateReferenceList::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_chronicle_v1::client::ReferenceListService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &ReferenceListService
    /// ) -> 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::reference_list_service::ListOperations {
        super::builder::reference_list_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_chronicle_v1::client::ReferenceListService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &ReferenceListService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::reference_list_service::GetOperation {
        super::builder::reference_list_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_chronicle_v1::client::ReferenceListService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &ReferenceListService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::reference_list_service::DeleteOperation {
        super::builder::reference_list_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_chronicle_v1::client::ReferenceListService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &ReferenceListService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::reference_list_service::CancelOperation {
        super::builder::reference_list_service::CancelOperation::new(self.inner.clone())
    }
}

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

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

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

    /// Creates a new Rule.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::RuleService;
    /// use google_cloud_chronicle_v1::model::Rule;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_rule()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .set_rule(
    ///             Rule::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_rule(&self) -> super::builder::rule_service::CreateRule {
        super::builder::rule_service::CreateRule::new(self.inner.clone())
    }

    /// Gets a Rule.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::RuleService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService, project_id: &str, location_id: &str, instance_id: &str, rule_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_rule()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/rules/{rule_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_rule(&self) -> super::builder::rule_service::GetRule {
        super::builder::rule_service::GetRule::new(self.inner.clone())
    }

    /// Lists Rules.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::RuleService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService, project_id: &str, location_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_rules()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_rules(&self) -> super::builder::rule_service::ListRules {
        super::builder::rule_service::ListRules::new(self.inner.clone())
    }

    /// Updates a Rule.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::RuleService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_chronicle_v1::model::Rule;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService, project_id: &str, location_id: &str, instance_id: &str, rule_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_rule()
    ///         .set_rule(
    ///             Rule::new().set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/rules/{rule_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_rule(&self) -> super::builder::rule_service::UpdateRule {
        super::builder::rule_service::UpdateRule::new(self.inner.clone())
    }

    /// Deletes a Rule.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::RuleService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService, project_id: &str, location_id: &str, instance_id: &str, rule_id: &str
    /// ) -> Result<()> {
    ///     client.delete_rule()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/rules/{rule_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_rule(&self) -> super::builder::rule_service::DeleteRule {
        super::builder::rule_service::DeleteRule::new(self.inner.clone())
    }

    /// Lists all revisions of the rule.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::RuleService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService
    /// ) -> Result<()> {
    ///     let mut list = client.list_rule_revisions()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_rule_revisions(&self) -> super::builder::rule_service::ListRuleRevisions {
        super::builder::rule_service::ListRuleRevisions::new(self.inner.clone())
    }

    /// Create a Retrohunt.
    ///
    /// # 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_chronicle_v1::client::RuleService;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_chronicle_v1::model::Retrohunt;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService, project_id: &str, location_id: &str, instance_id: &str, rule_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_retrohunt()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/rules/{rule_id}"))
    ///         .set_retrohunt(
    ///             Retrohunt::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_retrohunt(&self) -> super::builder::rule_service::CreateRetrohunt {
        super::builder::rule_service::CreateRetrohunt::new(self.inner.clone())
    }

    /// Get a Retrohunt.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::RuleService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService, project_id: &str, location_id: &str, instance_id: &str, rule_id: &str, retrohunt_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_retrohunt()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/rules/{rule_id}/retrohunts/{retrohunt_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_retrohunt(&self) -> super::builder::rule_service::GetRetrohunt {
        super::builder::rule_service::GetRetrohunt::new(self.inner.clone())
    }

    /// List Retrohunts.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::RuleService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService, project_id: &str, location_id: &str, instance_id: &str, rule_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_retrohunts()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/rules/{rule_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_retrohunts(&self) -> super::builder::rule_service::ListRetrohunts {
        super::builder::rule_service::ListRetrohunts::new(self.inner.clone())
    }

    /// Gets a RuleDeployment.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::RuleService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService, project_id: &str, location_id: &str, instance_id: &str, rule_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_rule_deployment()
    ///         .set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/rules/{rule_id}/deployment"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_rule_deployment(&self) -> super::builder::rule_service::GetRuleDeployment {
        super::builder::rule_service::GetRuleDeployment::new(self.inner.clone())
    }

    /// Lists RuleDeployments across all Rules.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::RuleService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService, project_id: &str, location_id: &str, instance_id: &str, rule_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_rule_deployments()
    ///         .set_parent(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/rules/{rule_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_rule_deployments(&self) -> super::builder::rule_service::ListRuleDeployments {
        super::builder::rule_service::ListRuleDeployments::new(self.inner.clone())
    }

    /// Updates a RuleDeployment.
    /// Failures are not necessarily atomic. If there is a request to update
    /// multiple fields, and any update to a single field fails, an error will be
    /// returned, but other fields may remain successfully updated.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_chronicle_v1::client::RuleService;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_chronicle_v1::model::RuleDeployment;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService, project_id: &str, location_id: &str, instance_id: &str, rule_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_rule_deployment()
    ///         .set_rule_deployment(
    ///             RuleDeployment::new().set_name(format!("projects/{project_id}/locations/{location_id}/instances/{instance_id}/rules/{rule_id}/deployment"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_rule_deployment(&self) -> super::builder::rule_service::UpdateRuleDeployment {
        super::builder::rule_service::UpdateRuleDeployment::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_chronicle_v1::client::RuleService;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService
    /// ) -> 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::rule_service::ListOperations {
        super::builder::rule_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_chronicle_v1::client::RuleService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::rule_service::GetOperation {
        super::builder::rule_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_chronicle_v1::client::RuleService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::rule_service::DeleteOperation {
        super::builder::rule_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_chronicle_v1::client::RuleService;
    /// use google_cloud_chronicle_v1::Result;
    /// async fn sample(
    ///    client: &RuleService
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::rule_service::CancelOperation {
        super::builder::rule_service::CancelOperation::new(self.inner.clone())
    }
}