google_cloud_bigtable_admin_v2/

client.rs

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

/// Implements a client for the Cloud Bigtable Admin API.
///
/// # Example
/// ```
/// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
/// use google_cloud_gax::paginator::ItemPaginator as _;
/// async fn sample(
///    project_id: &str,
///    instance_id: &str,
///    cluster_id: &str,
/// ) -> anyhow::Result<()> {
///     let client = BigtableInstanceAdmin::builder().build().await?;
///     let mut list = client.list_memory_layers()
///         .set_parent(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}"))
///         .by_item();
///     while let Some(item) = list.next().await.transpose()? {
///         println!("{:?}", item);
///     }
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// Service for creating, configuring, and deleting Cloud Bigtable Instances and
/// Clusters. Provides access to the Instance and Cluster schemas only, not the
/// tables' metadata or data stored in those tables.
///
/// # Configuration
///
/// To configure `BigtableInstanceAdmin` use the `with_*` methods in the type returned
/// by [builder()][BigtableInstanceAdmin::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://bigtableadmin.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::bigtable_instance_admin::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::bigtable_instance_admin::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
///
/// `BigtableInstanceAdmin` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `BigtableInstanceAdmin` 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 BigtableInstanceAdmin {
    inner: std::sync::Arc<dyn super::stub::dynamic::BigtableInstanceAdmin>,
}

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

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

    /// Create an instance within a project.
    ///
    /// Note that exactly one of Cluster.serve_nodes and
    /// Cluster.cluster_config.cluster_autoscaling_config can be set. If
    /// serve_nodes is set to non-zero, then the cluster is manually scaled. If
    /// cluster_config.cluster_autoscaling_config is non-empty, then autoscaling is
    /// enabled.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::model::Instance;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_instance()
    ///         .set_parent(parent)
    ///         .set_instance_id("instance_id_value")
    ///         .set_instance(
    ///             Instance::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_instance(&self) -> super::builder::bigtable_instance_admin::CreateInstance {
        super::builder::bigtable_instance_admin::CreateInstance::new(self.inner.clone())
    }

    /// Gets information about an instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_instance()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_instance(&self) -> super::builder::bigtable_instance_admin::GetInstance {
        super::builder::bigtable_instance_admin::GetInstance::new(self.inner.clone())
    }

    /// Lists information about instances in a project.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.list_instances()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn list_instances(&self) -> super::builder::bigtable_instance_admin::ListInstances {
        super::builder::bigtable_instance_admin::ListInstances::new(self.inner.clone())
    }

    /// Updates an instance within a project. This method updates only the display
    /// name and type for an Instance. To update other Instance properties, such as
    /// labels, use PartialUpdateInstance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.update_instance()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_instance(&self) -> super::builder::bigtable_instance_admin::UpdateInstance {
        super::builder::bigtable_instance_admin::UpdateInstance::new(self.inner.clone())
    }

    /// Partially updates an instance within a project. This method can modify all
    /// fields of an Instance and is the preferred way to update an Instance.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.partial_update_instance()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn partial_update_instance(
        &self,
    ) -> super::builder::bigtable_instance_admin::PartialUpdateInstance {
        super::builder::bigtable_instance_admin::PartialUpdateInstance::new(self.inner.clone())
    }

    /// Delete an instance from a project.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     client.delete_instance()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_instance(&self) -> super::builder::bigtable_instance_admin::DeleteInstance {
        super::builder::bigtable_instance_admin::DeleteInstance::new(self.inner.clone())
    }

    /// Creates a cluster within an instance.
    ///
    /// Note that exactly one of Cluster.serve_nodes and
    /// Cluster.cluster_config.cluster_autoscaling_config can be set. If
    /// serve_nodes is set to non-zero, then the cluster is manually scaled. If
    /// cluster_config.cluster_autoscaling_config is non-empty, then autoscaling is
    /// enabled.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::model::Cluster;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_cluster()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}"))
    ///         .set_cluster_id("cluster_id_value")
    ///         .set_cluster(
    ///             Cluster::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_cluster(&self) -> super::builder::bigtable_instance_admin::CreateCluster {
        super::builder::bigtable_instance_admin::CreateCluster::new(self.inner.clone())
    }

    /// Gets information about a cluster.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_cluster()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_cluster(&self) -> super::builder::bigtable_instance_admin::GetCluster {
        super::builder::bigtable_instance_admin::GetCluster::new(self.inner.clone())
    }

    /// Lists information about clusters in an instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.list_clusters()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn list_clusters(&self) -> super::builder::bigtable_instance_admin::ListClusters {
        super::builder::bigtable_instance_admin::ListClusters::new(self.inner.clone())
    }

    /// Updates a cluster within an instance.
    ///
    /// Note that UpdateCluster does not support updating
    /// cluster_config.cluster_autoscaling_config. In order to update it, you
    /// must use PartialUpdateCluster.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.update_cluster()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_cluster(&self) -> super::builder::bigtable_instance_admin::UpdateCluster {
        super::builder::bigtable_instance_admin::UpdateCluster::new(self.inner.clone())
    }

    /// Partially updates a cluster within a project. This method is the preferred
    /// way to update a Cluster.
    ///
    /// To enable and update autoscaling, set
    /// cluster_config.cluster_autoscaling_config. When autoscaling is enabled,
    /// serve_nodes is treated as an OUTPUT_ONLY field, meaning that updates to it
    /// are ignored. Note that an update cannot simultaneously set serve_nodes to
    /// non-zero and cluster_config.cluster_autoscaling_config to non-empty, and
    /// also specify both in the update_mask.
    ///
    /// To disable autoscaling, clear cluster_config.cluster_autoscaling_config,
    /// and explicitly set a serve_node count via the update_mask.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.partial_update_cluster()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn partial_update_cluster(
        &self,
    ) -> super::builder::bigtable_instance_admin::PartialUpdateCluster {
        super::builder::bigtable_instance_admin::PartialUpdateCluster::new(self.inner.clone())
    }

    /// Deletes a cluster from an instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     client.delete_cluster()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_cluster(&self) -> super::builder::bigtable_instance_admin::DeleteCluster {
        super::builder::bigtable_instance_admin::DeleteCluster::new(self.inner.clone())
    }

    /// Updates the memory layer of a cluster.
    ///
    /// To enable the memory layer, set the memory_config.
    /// To disable the memory layer, unset the memory_config.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_bigtable_admin_v2::model::MemoryLayer;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_memory_layer()
    ///         .set_memory_layer(
    ///             MemoryLayer::new().set_name(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}/memoryLayer"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_memory_layer(
        &self,
    ) -> super::builder::bigtable_instance_admin::UpdateMemoryLayer {
        super::builder::bigtable_instance_admin::UpdateMemoryLayer::new(self.inner.clone())
    }

    /// Lists information about memory layers.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_memory_layers()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_memory_layers(&self) -> super::builder::bigtable_instance_admin::ListMemoryLayers {
        super::builder::bigtable_instance_admin::ListMemoryLayers::new(self.inner.clone())
    }

    /// Gets information about the memory layer of a cluster.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_memory_layer()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}/memoryLayer"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_memory_layer(&self) -> super::builder::bigtable_instance_admin::GetMemoryLayer {
        super::builder::bigtable_instance_admin::GetMemoryLayer::new(self.inner.clone())
    }

    /// Creates an app profile within an instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::model::AppProfile;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_app_profile()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}"))
    ///         .set_app_profile(
    ///             AppProfile::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_app_profile(&self) -> super::builder::bigtable_instance_admin::CreateAppProfile {
        super::builder::bigtable_instance_admin::CreateAppProfile::new(self.inner.clone())
    }

    /// Gets information about an app profile.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, app_profile_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_app_profile()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/appProfiles/{app_profile_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_app_profile(&self) -> super::builder::bigtable_instance_admin::GetAppProfile {
        super::builder::bigtable_instance_admin::GetAppProfile::new(self.inner.clone())
    }

    /// Lists information about app profiles in an instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_app_profiles()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_app_profiles(&self) -> super::builder::bigtable_instance_admin::ListAppProfiles {
        super::builder::bigtable_instance_admin::ListAppProfiles::new(self.inner.clone())
    }

    /// Updates an app profile within an instance.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_bigtable_admin_v2::model::AppProfile;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, app_profile_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_app_profile()
    ///         .set_app_profile(
    ///             AppProfile::new().set_name(format!("projects/{project_id}/instances/{instance_id}/appProfiles/{app_profile_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_app_profile(&self) -> super::builder::bigtable_instance_admin::UpdateAppProfile {
        super::builder::bigtable_instance_admin::UpdateAppProfile::new(self.inner.clone())
    }

    /// Deletes an app profile from an instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, app_profile_id: &str
    /// ) -> Result<()> {
    ///     client.delete_app_profile()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/appProfiles/{app_profile_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_app_profile(&self) -> super::builder::bigtable_instance_admin::DeleteAppProfile {
        super::builder::bigtable_instance_admin::DeleteAppProfile::new(self.inner.clone())
    }

    /// Gets the access control policy for an instance resource. Returns an empty
    /// policy if an instance exists but does not have a policy set.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.get_iam_policy()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_iam_policy(&self) -> super::builder::bigtable_instance_admin::GetIamPolicy {
        super::builder::bigtable_instance_admin::GetIamPolicy::new(self.inner.clone())
    }

    /// Sets the access control policy on an instance resource. Replaces any
    /// existing policy.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.set_iam_policy()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn set_iam_policy(&self) -> super::builder::bigtable_instance_admin::SetIamPolicy {
        super::builder::bigtable_instance_admin::SetIamPolicy::new(self.inner.clone())
    }

    /// Returns permissions that the caller has on the specified instance resource.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.test_iam_permissions()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn test_iam_permissions(
        &self,
    ) -> super::builder::bigtable_instance_admin::TestIamPermissions {
        super::builder::bigtable_instance_admin::TestIamPermissions::new(self.inner.clone())
    }

    /// Lists hot tablets in a cluster, within the time range provided. Hot
    /// tablets are ordered based on CPU usage.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_hot_tablets()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_hot_tablets(&self) -> super::builder::bigtable_instance_admin::ListHotTablets {
        super::builder::bigtable_instance_admin::ListHotTablets::new(self.inner.clone())
    }

    /// Creates a logical view within an instance.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::model::LogicalView;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_logical_view()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}"))
    ///         .set_logical_view(
    ///             LogicalView::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_logical_view(
        &self,
    ) -> super::builder::bigtable_instance_admin::CreateLogicalView {
        super::builder::bigtable_instance_admin::CreateLogicalView::new(self.inner.clone())
    }

    /// Gets information about a logical view.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, logical_view_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_logical_view()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/logicalViews/{logical_view_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_logical_view(&self) -> super::builder::bigtable_instance_admin::GetLogicalView {
        super::builder::bigtable_instance_admin::GetLogicalView::new(self.inner.clone())
    }

    /// Lists information about logical views in an instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_logical_views()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_logical_views(&self) -> super::builder::bigtable_instance_admin::ListLogicalViews {
        super::builder::bigtable_instance_admin::ListLogicalViews::new(self.inner.clone())
    }

    /// Updates a logical view within an instance.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_bigtable_admin_v2::model::LogicalView;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, logical_view_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_logical_view()
    ///         .set_logical_view(
    ///             LogicalView::new().set_name(format!("projects/{project_id}/instances/{instance_id}/logicalViews/{logical_view_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_logical_view(
        &self,
    ) -> super::builder::bigtable_instance_admin::UpdateLogicalView {
        super::builder::bigtable_instance_admin::UpdateLogicalView::new(self.inner.clone())
    }

    /// Deletes a logical view from an instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, logical_view_id: &str
    /// ) -> Result<()> {
    ///     client.delete_logical_view()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/logicalViews/{logical_view_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_logical_view(
        &self,
    ) -> super::builder::bigtable_instance_admin::DeleteLogicalView {
        super::builder::bigtable_instance_admin::DeleteLogicalView::new(self.inner.clone())
    }

    /// Creates a materialized view within an instance.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::model::MaterializedView;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_materialized_view()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}"))
    ///         .set_materialized_view(
    ///             MaterializedView::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_materialized_view(
        &self,
    ) -> super::builder::bigtable_instance_admin::CreateMaterializedView {
        super::builder::bigtable_instance_admin::CreateMaterializedView::new(self.inner.clone())
    }

    /// Gets information about a materialized view.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, materialized_view_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_materialized_view()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/materializedViews/{materialized_view_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_materialized_view(
        &self,
    ) -> super::builder::bigtable_instance_admin::GetMaterializedView {
        super::builder::bigtable_instance_admin::GetMaterializedView::new(self.inner.clone())
    }

    /// Lists information about materialized views in an instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_materialized_views()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_materialized_views(
        &self,
    ) -> super::builder::bigtable_instance_admin::ListMaterializedViews {
        super::builder::bigtable_instance_admin::ListMaterializedViews::new(self.inner.clone())
    }

    /// Updates a materialized view within an instance.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_bigtable_admin_v2::model::MaterializedView;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, materialized_view_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_materialized_view()
    ///         .set_materialized_view(
    ///             MaterializedView::new().set_name(format!("projects/{project_id}/instances/{instance_id}/materializedViews/{materialized_view_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_materialized_view(
        &self,
    ) -> super::builder::bigtable_instance_admin::UpdateMaterializedView {
        super::builder::bigtable_instance_admin::UpdateMaterializedView::new(self.inner.clone())
    }

    /// Deletes a materialized view from an instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin, project_id: &str, instance_id: &str, materialized_view_id: &str
    /// ) -> Result<()> {
    ///     client.delete_materialized_view()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/materializedViews/{materialized_view_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_materialized_view(
        &self,
    ) -> super::builder::bigtable_instance_admin::DeleteMaterializedView {
        super::builder::bigtable_instance_admin::DeleteMaterializedView::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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin
    /// ) -> 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::bigtable_instance_admin::ListOperations {
        super::builder::bigtable_instance_admin::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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::bigtable_instance_admin::GetOperation {
        super::builder::bigtable_instance_admin::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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::bigtable_instance_admin::DeleteOperation {
        super::builder::bigtable_instance_admin::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_bigtable_admin_v2::client::BigtableInstanceAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableInstanceAdmin
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::bigtable_instance_admin::CancelOperation {
        super::builder::bigtable_instance_admin::CancelOperation::new(self.inner.clone())
    }
}

/// Implements a client for the Cloud Bigtable Admin API.
///
/// # Example
/// ```
/// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
/// use google_cloud_gax::paginator::ItemPaginator as _;
/// async fn sample(
///    project_id: &str,
///    instance_id: &str,
/// ) -> anyhow::Result<()> {
///     let client = BigtableTableAdmin::builder().build().await?;
///     let mut list = client.list_tables()
///         .set_parent(format!("projects/{project_id}/instances/{instance_id}"))
///         .by_item();
///     while let Some(item) = list.next().await.transpose()? {
///         println!("{:?}", item);
///     }
///     Ok(())
/// }
/// ```
///
/// # Service Description
///
/// Service for creating, configuring, and deleting Cloud Bigtable tables.
///
/// Provides access to the table schemas only, not the data stored within
/// the tables.
///
/// # Configuration
///
/// To configure `BigtableTableAdmin` use the `with_*` methods in the type returned
/// by [builder()][BigtableTableAdmin::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://bigtableadmin.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::bigtable_table_admin::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::bigtable_table_admin::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
///
/// `BigtableTableAdmin` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `BigtableTableAdmin` 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 BigtableTableAdmin {
    inner: std::sync::Arc<dyn super::stub::dynamic::BigtableTableAdmin>,
}

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

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

    /// Creates a new table in the specified instance.
    /// The table can be created with a full set of initial column families,
    /// specified in the request.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::model::Table;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_table()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}"))
    ///         .set_table_id("table_id_value")
    ///         .set_table(
    ///             Table::new()/* set fields */
    ///         )
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_table(&self) -> super::builder::bigtable_table_admin::CreateTable {
        super::builder::bigtable_table_admin::CreateTable::new(self.inner.clone())
    }

    /// Creates a new table from the specified snapshot. The target table must
    /// not exist. The snapshot and the table must be in the same instance.
    ///
    /// Note: This is a private alpha release of Cloud Bigtable snapshots. This
    /// feature is not currently available to most Cloud Bigtable customers. This
    /// feature might be changed in backward-incompatible ways and is not
    /// recommended for production use. It is not subject to any SLA or deprecation
    /// policy.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     let response = client.create_table_from_snapshot()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_table_from_snapshot(
        &self,
    ) -> super::builder::bigtable_table_admin::CreateTableFromSnapshot {
        super::builder::bigtable_table_admin::CreateTableFromSnapshot::new(self.inner.clone())
    }

    /// Lists all tables served from a specified instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_tables()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_tables(&self) -> super::builder::bigtable_table_admin::ListTables {
        super::builder::bigtable_table_admin::ListTables::new(self.inner.clone())
    }

    /// Gets metadata information about the specified table.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_table()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_table(&self) -> super::builder::bigtable_table_admin::GetTable {
        super::builder::bigtable_table_admin::GetTable::new(self.inner.clone())
    }

    /// Updates a specified table.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_bigtable_admin_v2::model::Table;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_table()
    ///         .set_table(
    ///             Table::new().set_name(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_table(&self) -> super::builder::bigtable_table_admin::UpdateTable {
        super::builder::bigtable_table_admin::UpdateTable::new(self.inner.clone())
    }

    /// Permanently deletes a specified table and all of its data.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str
    /// ) -> Result<()> {
    ///     client.delete_table()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_table(&self) -> super::builder::bigtable_table_admin::DeleteTable {
        super::builder::bigtable_table_admin::DeleteTable::new(self.inner.clone())
    }

    /// Restores a specified table which was accidentally deleted.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str
    /// ) -> Result<()> {
    ///     let response = client.undelete_table()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}"))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn undelete_table(&self) -> super::builder::bigtable_table_admin::UndeleteTable {
        super::builder::bigtable_table_admin::UndeleteTable::new(self.inner.clone())
    }

    /// Creates a new AuthorizedView in a table.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::model::AuthorizedView;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_authorized_view()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}"))
    ///         .set_authorized_view(
    ///             AuthorizedView::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_authorized_view(
        &self,
    ) -> super::builder::bigtable_table_admin::CreateAuthorizedView {
        super::builder::bigtable_table_admin::CreateAuthorizedView::new(self.inner.clone())
    }

    /// Lists all AuthorizedViews from a specific table.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_authorized_views()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_authorized_views(
        &self,
    ) -> super::builder::bigtable_table_admin::ListAuthorizedViews {
        super::builder::bigtable_table_admin::ListAuthorizedViews::new(self.inner.clone())
    }

    /// Gets information from a specified AuthorizedView.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str, authorized_view_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_authorized_view()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}/authorizedViews/{authorized_view_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_authorized_view(&self) -> super::builder::bigtable_table_admin::GetAuthorizedView {
        super::builder::bigtable_table_admin::GetAuthorizedView::new(self.inner.clone())
    }

    /// Updates an AuthorizedView in a table.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_bigtable_admin_v2::model::AuthorizedView;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str, authorized_view_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_authorized_view()
    ///         .set_authorized_view(
    ///             AuthorizedView::new().set_name(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}/authorizedViews/{authorized_view_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_authorized_view(
        &self,
    ) -> super::builder::bigtable_table_admin::UpdateAuthorizedView {
        super::builder::bigtable_table_admin::UpdateAuthorizedView::new(self.inner.clone())
    }

    /// Permanently deletes a specified AuthorizedView.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str, authorized_view_id: &str
    /// ) -> Result<()> {
    ///     client.delete_authorized_view()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}/authorizedViews/{authorized_view_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_authorized_view(
        &self,
    ) -> super::builder::bigtable_table_admin::DeleteAuthorizedView {
        super::builder::bigtable_table_admin::DeleteAuthorizedView::new(self.inner.clone())
    }

    /// Performs a series of column family modifications on the specified table.
    /// Either all or none of the modifications will occur before this method
    /// returns, but data requests received prior to that point may see a table
    /// where only some modifications have taken effect.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     let response = client.modify_column_families()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn modify_column_families(
        &self,
    ) -> super::builder::bigtable_table_admin::ModifyColumnFamilies {
        super::builder::bigtable_table_admin::ModifyColumnFamilies::new(self.inner.clone())
    }

    /// Permanently drop/delete a row range from a specified table. The request can
    /// specify whether to delete all rows in a table, or only those that match a
    /// particular prefix.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     client.drop_row_range()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn drop_row_range(&self) -> super::builder::bigtable_table_admin::DropRowRange {
        super::builder::bigtable_table_admin::DropRowRange::new(self.inner.clone())
    }

    /// Generates a consistency token for a Table, which can be used in
    /// CheckConsistency to check whether mutations to the table that finished
    /// before this call started have been replicated. The tokens will be available
    /// for 90 days.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     let response = client.generate_consistency_token()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn generate_consistency_token(
        &self,
    ) -> super::builder::bigtable_table_admin::GenerateConsistencyToken {
        super::builder::bigtable_table_admin::GenerateConsistencyToken::new(self.inner.clone())
    }

    /// Checks replication consistency based on a consistency token, that is, if
    /// replication has caught up based on the conditions specified in the token
    /// and the check request.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     let response = client.check_consistency()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn check_consistency(&self) -> super::builder::bigtable_table_admin::CheckConsistency {
        super::builder::bigtable_table_admin::CheckConsistency::new(self.inner.clone())
    }

    /// Creates a new snapshot in the specified cluster from the specified
    /// source table. The cluster and the table must be in the same instance.
    ///
    /// Note: This is a private alpha release of Cloud Bigtable snapshots. This
    /// feature is not currently available to most Cloud Bigtable customers. This
    /// feature might be changed in backward-incompatible ways and is not
    /// recommended for production use. It is not subject to any SLA or deprecation
    /// policy.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     let response = client.snapshot_table()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn snapshot_table(&self) -> super::builder::bigtable_table_admin::SnapshotTable {
        super::builder::bigtable_table_admin::SnapshotTable::new(self.inner.clone())
    }

    /// Gets metadata information about the specified snapshot.
    ///
    /// Note: This is a private alpha release of Cloud Bigtable snapshots. This
    /// feature is not currently available to most Cloud Bigtable customers. This
    /// feature might be changed in backward-incompatible ways and is not
    /// recommended for production use. It is not subject to any SLA or deprecation
    /// policy.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, cluster_id: &str, snapshot_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_snapshot()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}/snapshots/{snapshot_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_snapshot(&self) -> super::builder::bigtable_table_admin::GetSnapshot {
        super::builder::bigtable_table_admin::GetSnapshot::new(self.inner.clone())
    }

    /// Lists all snapshots associated with the specified cluster.
    ///
    /// Note: This is a private alpha release of Cloud Bigtable snapshots. This
    /// feature is not currently available to most Cloud Bigtable customers. This
    /// feature might be changed in backward-incompatible ways and is not
    /// recommended for production use. It is not subject to any SLA or deprecation
    /// policy.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_snapshots()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_snapshots(&self) -> super::builder::bigtable_table_admin::ListSnapshots {
        super::builder::bigtable_table_admin::ListSnapshots::new(self.inner.clone())
    }

    /// Permanently deletes the specified snapshot.
    ///
    /// Note: This is a private alpha release of Cloud Bigtable snapshots. This
    /// feature is not currently available to most Cloud Bigtable customers. This
    /// feature might be changed in backward-incompatible ways and is not
    /// recommended for production use. It is not subject to any SLA or deprecation
    /// policy.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, cluster_id: &str, snapshot_id: &str
    /// ) -> Result<()> {
    ///     client.delete_snapshot()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}/snapshots/{snapshot_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_snapshot(&self) -> super::builder::bigtable_table_admin::DeleteSnapshot {
        super::builder::bigtable_table_admin::DeleteSnapshot::new(self.inner.clone())
    }

    /// Starts creating a new Cloud Bigtable Backup.  The returned backup
    /// [long-running operation][google.longrunning.Operation] can be used to
    /// track creation of the backup. The
    /// [metadata][google.longrunning.Operation.metadata] field type is
    /// [CreateBackupMetadata][google.bigtable.admin.v2.CreateBackupMetadata]. The
    /// [response][google.longrunning.Operation.response] field type is
    /// [Backup][google.bigtable.admin.v2.Backup], if successful. Cancelling the
    /// returned operation will stop the creation and delete the backup.
    ///
    /// [google.bigtable.admin.v2.Backup]: crate::model::Backup
    /// [google.bigtable.admin.v2.CreateBackupMetadata]: crate::model::CreateBackupMetadata
    /// [google.longrunning.Operation]: google_cloud_longrunning::model::Operation
    /// [google.longrunning.Operation.metadata]: google_cloud_longrunning::model::Operation::metadata
    /// [google.longrunning.Operation.response]: google_cloud_longrunning::model::Operation::result
    ///
    /// # 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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::model::Backup;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_backup()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}"))
    ///         .set_backup_id("backup_id_value")
    ///         .set_backup(
    ///             Backup::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_backup(&self) -> super::builder::bigtable_table_admin::CreateBackup {
        super::builder::bigtable_table_admin::CreateBackup::new(self.inner.clone())
    }

    /// Gets metadata on a pending or completed Cloud Bigtable Backup.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, cluster_id: &str, backup_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_backup()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}/backups/{backup_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_backup(&self) -> super::builder::bigtable_table_admin::GetBackup {
        super::builder::bigtable_table_admin::GetBackup::new(self.inner.clone())
    }

    /// Updates a pending or completed Cloud Bigtable Backup.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_bigtable_admin_v2::model::Backup;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, cluster_id: &str, backup_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_backup()
    ///         .set_backup(
    ///             Backup::new().set_name(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}/backups/{backup_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_backup(&self) -> super::builder::bigtable_table_admin::UpdateBackup {
        super::builder::bigtable_table_admin::UpdateBackup::new(self.inner.clone())
    }

    /// Deletes a pending or completed Cloud Bigtable backup.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, cluster_id: &str, backup_id: &str
    /// ) -> Result<()> {
    ///     client.delete_backup()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}/backups/{backup_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_backup(&self) -> super::builder::bigtable_table_admin::DeleteBackup {
        super::builder::bigtable_table_admin::DeleteBackup::new(self.inner.clone())
    }

    /// Lists Cloud Bigtable backups. Returns both completed and pending
    /// backups.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, cluster_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_backups()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}/clusters/{cluster_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_backups(&self) -> super::builder::bigtable_table_admin::ListBackups {
        super::builder::bigtable_table_admin::ListBackups::new(self.inner.clone())
    }

    /// Create a new table by restoring from a completed backup.  The
    /// returned table [long-running operation][google.longrunning.Operation] can
    /// be used to track the progress of the operation, and to cancel it.  The
    /// [metadata][google.longrunning.Operation.metadata] field type is
    /// [RestoreTableMetadata][google.bigtable.admin.v2.RestoreTableMetadata].  The
    /// [response][google.longrunning.Operation.response] type is
    /// [Table][google.bigtable.admin.v2.Table], if successful.
    ///
    /// [google.bigtable.admin.v2.RestoreTableMetadata]: crate::model::RestoreTableMetadata
    /// [google.bigtable.admin.v2.Table]: crate::model::Table
    /// [google.longrunning.Operation]: google_cloud_longrunning::model::Operation
    /// [google.longrunning.Operation.metadata]: google_cloud_longrunning::model::Operation::metadata
    /// [google.longrunning.Operation.response]: google_cloud_longrunning::model::Operation::result
    ///
    /// # 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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     let response = client.restore_table()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn restore_table(&self) -> super::builder::bigtable_table_admin::RestoreTable {
        super::builder::bigtable_table_admin::RestoreTable::new(self.inner.clone())
    }

    /// Copy a Cloud Bigtable backup to a new backup in the destination cluster
    /// located in the destination instance and project.
    ///
    /// # Long running operations
    ///
    /// This method is used to start, and/or poll a [long-running Operation].
    /// The [Working with long-running operations] chapter in the [user guide]
    /// covers these operations in detail.
    ///
    /// [long-running operation]: https://google.aip.dev/151
    /// [user guide]: https://googleapis.github.io/google-cloud-rust/
    /// [working with long-running operations]: https://googleapis.github.io/google-cloud-rust/working_with_long_running_operations.html
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     let response = client.copy_backup()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn copy_backup(&self) -> super::builder::bigtable_table_admin::CopyBackup {
        super::builder::bigtable_table_admin::CopyBackup::new(self.inner.clone())
    }

    /// Gets the access control policy for a Bigtable resource.
    /// Returns an empty policy if the resource exists but does not have a policy
    /// set.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     let response = client.get_iam_policy()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_iam_policy(&self) -> super::builder::bigtable_table_admin::GetIamPolicy {
        super::builder::bigtable_table_admin::GetIamPolicy::new(self.inner.clone())
    }

    /// Sets the access control policy on a Bigtable resource.
    /// Replaces any existing policy.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     let response = client.set_iam_policy()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn set_iam_policy(&self) -> super::builder::bigtable_table_admin::SetIamPolicy {
        super::builder::bigtable_table_admin::SetIamPolicy::new(self.inner.clone())
    }

    /// Returns permissions that the caller has on the specified Bigtable
    /// resource.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     let response = client.test_iam_permissions()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn test_iam_permissions(&self) -> super::builder::bigtable_table_admin::TestIamPermissions {
        super::builder::bigtable_table_admin::TestIamPermissions::new(self.inner.clone())
    }

    /// Creates a new schema bundle in the specified table.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_bigtable_admin_v2::model::SchemaBundle;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str
    /// ) -> Result<()> {
    ///     let response = client.create_schema_bundle()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}"))
    ///         .set_schema_bundle(
    ///             SchemaBundle::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_schema_bundle(&self) -> super::builder::bigtable_table_admin::CreateSchemaBundle {
        super::builder::bigtable_table_admin::CreateSchemaBundle::new(self.inner.clone())
    }

    /// Updates a schema bundle in the specified table.
    ///
    /// # 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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_bigtable_admin_v2::model::SchemaBundle;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str, schema_bundle_id: &str
    /// ) -> Result<()> {
    ///     let response = client.update_schema_bundle()
    ///         .set_schema_bundle(
    ///             SchemaBundle::new().set_name(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}/schemaBundles/{schema_bundle_id}"))/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_schema_bundle(&self) -> super::builder::bigtable_table_admin::UpdateSchemaBundle {
        super::builder::bigtable_table_admin::UpdateSchemaBundle::new(self.inner.clone())
    }

    /// Gets metadata information about the specified schema bundle.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str, schema_bundle_id: &str
    /// ) -> Result<()> {
    ///     let response = client.get_schema_bundle()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}/schemaBundles/{schema_bundle_id}"))
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_schema_bundle(&self) -> super::builder::bigtable_table_admin::GetSchemaBundle {
        super::builder::bigtable_table_admin::GetSchemaBundle::new(self.inner.clone())
    }

    /// Lists all schema bundles associated with the specified table.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_schema_bundles()
    ///         .set_parent(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}"))
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_schema_bundles(&self) -> super::builder::bigtable_table_admin::ListSchemaBundles {
        super::builder::bigtable_table_admin::ListSchemaBundles::new(self.inner.clone())
    }

    /// Deletes a schema bundle in the specified table.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin, project_id: &str, instance_id: &str, table_id: &str, schema_bundle_id: &str
    /// ) -> Result<()> {
    ///     client.delete_schema_bundle()
    ///         .set_name(format!("projects/{project_id}/instances/{instance_id}/tables/{table_id}/schemaBundles/{schema_bundle_id}"))
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_schema_bundle(&self) -> super::builder::bigtable_table_admin::DeleteSchemaBundle {
        super::builder::bigtable_table_admin::DeleteSchemaBundle::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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> 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::bigtable_table_admin::ListOperations {
        super::builder::bigtable_table_admin::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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::bigtable_table_admin::GetOperation {
        super::builder::bigtable_table_admin::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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::bigtable_table_admin::DeleteOperation {
        super::builder::bigtable_table_admin::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_bigtable_admin_v2::client::BigtableTableAdmin;
    /// use google_cloud_bigtable_admin_v2::Result;
    /// async fn sample(
    ///    client: &BigtableTableAdmin
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::bigtable_table_admin::CancelOperation {
        super::builder::bigtable_table_admin::CancelOperation::new(self.inner.clone())
    }
}