google-cloud-spanner-admin-instance-v1 1.8.0

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

/// Implements a client for the Cloud Spanner API.
///
/// # Example
/// ```
/// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
/// use google_cloud_gax::paginator::ItemPaginator as _;
/// # async fn sample() -> Result<(), Box<dyn std::error::Error>> {
///     let client = InstanceAdmin::builder().build().await?;
///     let parent = "parent_value";
///     let mut list = client.list_instance_configs()
///         .set_parent(parent)
///         .by_item();
///     while let Some(item) = list.next().await.transpose()? {
///         println!("{:?}", item);
///     }
/// # Ok(()) }
/// ```
///
/// # Service Description
///
/// Cloud Spanner Instance Admin API
///
/// The Cloud Spanner Instance Admin API can be used to create, delete,
/// modify and list instances. Instances are dedicated Cloud Spanner serving
/// and storage resources to be used by Cloud Spanner databases.
///
/// Each instance has a "configuration", which dictates where the
/// serving resources for the Cloud Spanner instance are located (e.g.,
/// US-central, Europe). Configurations are created by Google based on
/// resource availability.
///
/// Cloud Spanner billing is based on the instances that exist and their
/// sizes. After an instance exists, there are no additional
/// per-database or per-operation charges for use of the instance
/// (though there may be additional network bandwidth charges).
/// Instances offer isolation: problems with databases in one instance
/// will not affect other instances. However, within an instance
/// databases can affect each other. For example, if one database in an
/// instance receives a lot of requests and consumes most of the
/// instance resources, fewer resources are available for other
/// databases in that instance, and their performance may suffer.
///
/// # Configuration
///
/// To configure `InstanceAdmin` use the `with_*` methods in the type returned
/// by [builder()][InstanceAdmin::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://spanner.googleapis.com`). Applications using regional
///   endpoints or running in restricted networks (e.g. a network configured
//    with [Private Google Access with VPC Service Controls]) may want to
///   override this default.
/// * [with_credentials()]: by default this client uses
///   [Application Default Credentials]. Applications using custom
///   authentication may need to override this default.
///
/// [with_endpoint()]: super::builder::instance_admin::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::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
///
/// `InstanceAdmin` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `InstanceAdmin` 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 InstanceAdmin {
    inner: std::sync::Arc<dyn super::stub::dynamic::InstanceAdmin>,
}

impl InstanceAdmin {
    /// Returns a builder for [InstanceAdmin].
    ///
    /// ```
    /// # async fn sample() -> google_cloud_gax::client_builder::Result<()> {
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// let client = InstanceAdmin::builder().build().await?;
    /// # Ok(()) }
    /// ```
    pub fn builder() -> super::builder::instance_admin::ClientBuilder {
        crate::new_client_builder(super::builder::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: T) -> Self
    where
        T: super::stub::InstanceAdmin + 'static,
    {
        Self {
            inner: std::sync::Arc::new(stub),
        }
    }

    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::InstanceAdmin>> {
        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::InstanceAdmin> {
        super::transport::InstanceAdmin::new(conf).await
    }

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

    /// Lists the supported instance configurations for a given project.
    ///
    /// Returns both Google-managed configurations and user-managed
    /// configurations.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_instance_configs()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_instance_configs(&self) -> super::builder::instance_admin::ListInstanceConfigs {
        super::builder::instance_admin::ListInstanceConfigs::new(self.inner.clone())
    }

    /// Gets information about a particular instance configuration.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_instance_config()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_instance_config(&self) -> super::builder::instance_admin::GetInstanceConfig {
        super::builder::instance_admin::GetInstanceConfig::new(self.inner.clone())
    }

    /// Creates an instance configuration and begins preparing it to be used. The
    /// returned long-running operation
    /// can be used to track the progress of preparing the new
    /// instance configuration. The instance configuration name is assigned by the
    /// caller. If the named instance configuration already exists,
    /// `CreateInstanceConfig` returns `ALREADY_EXISTS`.
    ///
    /// Immediately after the request returns:
    ///
    /// * The instance configuration is readable via the API, with all requested
    ///   attributes. The instance configuration's
    ///   [reconciling][google.spanner.admin.instance.v1.InstanceConfig.reconciling]
    ///   field is set to true. Its state is `CREATING`.
    ///
    /// While the operation is pending:
    ///
    /// * Cancelling the operation renders the instance configuration immediately
    ///   unreadable via the API.
    /// * Except for deleting the creating resource, all other attempts to modify
    ///   the instance configuration are rejected.
    ///
    /// Upon completion of the returned operation:
    ///
    /// * Instances can be created using the instance configuration.
    /// * The instance configuration's
    ///   [reconciling][google.spanner.admin.instance.v1.InstanceConfig.reconciling]
    ///   field becomes false. Its state becomes `READY`.
    ///
    /// The returned long-running operation will
    /// have a name of the format
    /// `<instance_config_name>/operations/<operation_id>` and can be used to track
    /// creation of the instance configuration. The
    /// metadata field type is
    /// [CreateInstanceConfigMetadata][google.spanner.admin.instance.v1.CreateInstanceConfigMetadata].
    /// The response field type is
    /// [InstanceConfig][google.spanner.admin.instance.v1.InstanceConfig], if
    /// successful.
    ///
    /// Authorization requires `spanner.instanceConfigs.create` permission on
    /// the resource
    /// [parent][google.spanner.admin.instance.v1.CreateInstanceConfigRequest.parent].
    ///
    /// [google.spanner.admin.instance.v1.CreateInstanceConfigMetadata]: crate::model::CreateInstanceConfigMetadata
    /// [google.spanner.admin.instance.v1.CreateInstanceConfigRequest.parent]: crate::model::CreateInstanceConfigRequest::parent
    /// [google.spanner.admin.instance.v1.InstanceConfig]: crate::model::InstanceConfig
    /// [google.spanner.admin.instance.v1.InstanceConfig.reconciling]: crate::model::InstanceConfig::reconciling
    ///
    /// # 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_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.create_instance_config()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_instance_config(&self) -> super::builder::instance_admin::CreateInstanceConfig {
        super::builder::instance_admin::CreateInstanceConfig::new(self.inner.clone())
    }

    /// Updates an instance configuration. The returned
    /// long-running operation can be used to track
    /// the progress of updating the instance. If the named instance configuration
    /// does not exist, returns `NOT_FOUND`.
    ///
    /// Only user-managed configurations can be updated.
    ///
    /// Immediately after the request returns:
    ///
    /// * The instance configuration's
    ///   [reconciling][google.spanner.admin.instance.v1.InstanceConfig.reconciling]
    ///   field is set to true.
    ///
    /// While the operation is pending:
    ///
    /// * Cancelling the operation sets its metadata's
    ///   [cancel_time][google.spanner.admin.instance.v1.UpdateInstanceConfigMetadata.cancel_time].
    ///   The operation is guaranteed to succeed at undoing all changes, after
    ///   which point it terminates with a `CANCELLED` status.
    /// * All other attempts to modify the instance configuration are rejected.
    /// * Reading the instance configuration via the API continues to give the
    ///   pre-request values.
    ///
    /// Upon completion of the returned operation:
    ///
    /// * Creating instances using the instance configuration uses the new
    ///   values.
    /// * The new values of the instance configuration are readable via the API.
    /// * The instance configuration's
    ///   [reconciling][google.spanner.admin.instance.v1.InstanceConfig.reconciling]
    ///   field becomes false.
    ///
    /// The returned long-running operation will
    /// have a name of the format
    /// `<instance_config_name>/operations/<operation_id>` and can be used to track
    /// the instance configuration modification.  The
    /// metadata field type is
    /// [UpdateInstanceConfigMetadata][google.spanner.admin.instance.v1.UpdateInstanceConfigMetadata].
    /// The response field type is
    /// [InstanceConfig][google.spanner.admin.instance.v1.InstanceConfig], if
    /// successful.
    ///
    /// Authorization requires `spanner.instanceConfigs.update` permission on
    /// the resource [name][google.spanner.admin.instance.v1.InstanceConfig.name].
    ///
    /// [google.spanner.admin.instance.v1.InstanceConfig]: crate::model::InstanceConfig
    /// [google.spanner.admin.instance.v1.InstanceConfig.name]: crate::model::InstanceConfig::name
    /// [google.spanner.admin.instance.v1.InstanceConfig.reconciling]: crate::model::InstanceConfig::reconciling
    /// [google.spanner.admin.instance.v1.UpdateInstanceConfigMetadata]: crate::model::UpdateInstanceConfigMetadata
    /// [google.spanner.admin.instance.v1.UpdateInstanceConfigMetadata.cancel_time]: crate::model::UpdateInstanceConfigMetadata::cancel_time
    ///
    /// # 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_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.update_instance_config()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_instance_config(&self) -> super::builder::instance_admin::UpdateInstanceConfig {
        super::builder::instance_admin::UpdateInstanceConfig::new(self.inner.clone())
    }

    /// Deletes the instance configuration. Deletion is only allowed when no
    /// instances are using the configuration. If any instances are using
    /// the configuration, returns `FAILED_PRECONDITION`.
    ///
    /// Only user-managed configurations can be deleted.
    ///
    /// Authorization requires `spanner.instanceConfigs.delete` permission on
    /// the resource [name][google.spanner.admin.instance.v1.InstanceConfig.name].
    ///
    /// [google.spanner.admin.instance.v1.InstanceConfig.name]: crate::model::InstanceConfig::name
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin, name: &str
    /// ) -> Result<()> {
    ///     client.delete_instance_config()
    ///         .set_name(name)
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_instance_config(&self) -> super::builder::instance_admin::DeleteInstanceConfig {
        super::builder::instance_admin::DeleteInstanceConfig::new(self.inner.clone())
    }

    /// Lists the user-managed instance configuration long-running
    /// operations in the given project. An instance
    /// configuration operation has a name of the form
    /// `projects/<project>/instanceConfigs/<instance_config>/operations/<operation>`.
    /// The long-running operation
    /// metadata field type
    /// `metadata.type_url` describes the type of the metadata. Operations returned
    /// include those that have completed/failed/canceled within the last 7 days,
    /// and pending operations. Operations returned are ordered by
    /// `operation.metadata.value.start_time` in descending order starting
    /// from the most recently started operation.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     let mut list = client.list_instance_config_operations()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_instance_config_operations(
        &self,
    ) -> super::builder::instance_admin::ListInstanceConfigOperations {
        super::builder::instance_admin::ListInstanceConfigOperations::new(self.inner.clone())
    }

    /// Lists all instances in the given project.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_instances()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_instances(&self) -> super::builder::instance_admin::ListInstances {
        super::builder::instance_admin::ListInstances::new(self.inner.clone())
    }

    /// Lists all instance partitions for the given instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_instance_partitions()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_instance_partitions(
        &self,
    ) -> super::builder::instance_admin::ListInstancePartitions {
        super::builder::instance_admin::ListInstancePartitions::new(self.inner.clone())
    }

    /// Gets information about a particular instance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_instance()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_instance(&self) -> super::builder::instance_admin::GetInstance {
        super::builder::instance_admin::GetInstance::new(self.inner.clone())
    }

    /// Creates an instance and begins preparing it to begin serving. The
    /// returned long-running operation
    /// can be used to track the progress of preparing the new
    /// instance. The instance name is assigned by the caller. If the
    /// named instance already exists, `CreateInstance` returns
    /// `ALREADY_EXISTS`.
    ///
    /// Immediately upon completion of this request:
    ///
    /// * The instance is readable via the API, with all requested attributes
    ///   but no allocated resources. Its state is `CREATING`.
    ///
    /// Until completion of the returned operation:
    ///
    /// * Cancelling the operation renders the instance immediately unreadable
    ///   via the API.
    /// * The instance can be deleted.
    /// * All other attempts to modify the instance are rejected.
    ///
    /// Upon completion of the returned operation:
    ///
    /// * Billing for all successfully-allocated resources begins (some types
    ///   may have lower than the requested levels).
    /// * Databases can be created in the instance.
    /// * The instance's allocated resource levels are readable via the API.
    /// * The instance's state becomes `READY`.
    ///
    /// The returned long-running operation will
    /// have a name of the format `<instance_name>/operations/<operation_id>` and
    /// can be used to track creation of the instance.  The
    /// metadata field type is
    /// [CreateInstanceMetadata][google.spanner.admin.instance.v1.CreateInstanceMetadata].
    /// The response field type is
    /// [Instance][google.spanner.admin.instance.v1.Instance], if successful.
    ///
    /// [google.spanner.admin.instance.v1.CreateInstanceMetadata]: crate::model::CreateInstanceMetadata
    /// [google.spanner.admin.instance.v1.Instance]: crate::model::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_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_spanner_admin_instance_v1::model::Instance;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin, 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::instance_admin::CreateInstance {
        super::builder::instance_admin::CreateInstance::new(self.inner.clone())
    }

    /// Updates an instance, and begins allocating or releasing resources
    /// as requested. The returned long-running operation can be used to track the
    /// progress of updating the instance. If the named instance does not
    /// exist, returns `NOT_FOUND`.
    ///
    /// Immediately upon completion of this request:
    ///
    /// * For resource types for which a decrease in the instance's allocation
    ///   has been requested, billing is based on the newly-requested level.
    ///
    /// Until completion of the returned operation:
    ///
    /// * Cancelling the operation sets its metadata's
    ///   [cancel_time][google.spanner.admin.instance.v1.UpdateInstanceMetadata.cancel_time],
    ///   and begins restoring resources to their pre-request values. The
    ///   operation is guaranteed to succeed at undoing all resource changes,
    ///   after which point it terminates with a `CANCELLED` status.
    /// * All other attempts to modify the instance are rejected.
    /// * Reading the instance via the API continues to give the pre-request
    ///   resource levels.
    ///
    /// Upon completion of the returned operation:
    ///
    /// * Billing begins for all successfully-allocated resources (some types
    ///   may have lower than the requested levels).
    /// * All newly-reserved resources are available for serving the instance's
    ///   tables.
    /// * The instance's new resource levels are readable via the API.
    ///
    /// The returned long-running operation will
    /// have a name of the format `<instance_name>/operations/<operation_id>` and
    /// can be used to track the instance modification.  The
    /// metadata field type is
    /// [UpdateInstanceMetadata][google.spanner.admin.instance.v1.UpdateInstanceMetadata].
    /// The response field type is
    /// [Instance][google.spanner.admin.instance.v1.Instance], if successful.
    ///
    /// Authorization requires `spanner.instances.update` permission on
    /// the resource [name][google.spanner.admin.instance.v1.Instance.name].
    ///
    /// [google.spanner.admin.instance.v1.Instance]: crate::model::Instance
    /// [google.spanner.admin.instance.v1.Instance.name]: crate::model::Instance::name
    /// [google.spanner.admin.instance.v1.UpdateInstanceMetadata]: crate::model::UpdateInstanceMetadata
    /// [google.spanner.admin.instance.v1.UpdateInstanceMetadata.cancel_time]: crate::model::UpdateInstanceMetadata::cancel_time
    ///
    /// # 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_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_spanner_admin_instance_v1::model::Instance;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin, name: &str
    /// ) -> Result<()> {
    ///     let response = client.update_instance()
    ///         .set_instance(
    ///             Instance::new().set_name(name)/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_instance(&self) -> super::builder::instance_admin::UpdateInstance {
        super::builder::instance_admin::UpdateInstance::new(self.inner.clone())
    }

    /// Deletes an instance.
    ///
    /// Immediately upon completion of the request:
    ///
    /// * Billing ceases for all of the instance's reserved resources.
    ///
    /// Soon afterward:
    ///
    /// * The instance and *all of its databases* immediately and
    ///   irrevocably disappear from the API. All data in the databases
    ///   is permanently deleted.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin, name: &str
    /// ) -> Result<()> {
    ///     client.delete_instance()
    ///         .set_name(name)
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_instance(&self) -> super::builder::instance_admin::DeleteInstance {
        super::builder::instance_admin::DeleteInstance::new(self.inner.clone())
    }

    /// Sets the access control policy on an instance resource. Replaces any
    /// existing policy.
    ///
    /// Authorization requires `spanner.instances.setIamPolicy` on
    /// [resource][google.iam.v1.SetIamPolicyRequest.resource].
    ///
    /// [google.iam.v1.SetIamPolicyRequest.resource]: google_cloud_iam_v1::model::SetIamPolicyRequest::resource
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.set_iam_policy()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn set_iam_policy(&self) -> super::builder::instance_admin::SetIamPolicy {
        super::builder::instance_admin::SetIamPolicy::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.
    ///
    /// Authorization requires `spanner.instances.getIamPolicy` on
    /// [resource][google.iam.v1.GetIamPolicyRequest.resource].
    ///
    /// [google.iam.v1.GetIamPolicyRequest.resource]: google_cloud_iam_v1::model::GetIamPolicyRequest::resource
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.get_iam_policy()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_iam_policy(&self) -> super::builder::instance_admin::GetIamPolicy {
        super::builder::instance_admin::GetIamPolicy::new(self.inner.clone())
    }

    /// Returns permissions that the caller has on the specified instance resource.
    ///
    /// Attempting this RPC on a non-existent Cloud Spanner instance resource will
    /// result in a NOT_FOUND error if the user has `spanner.instances.list`
    /// permission on the containing Google Cloud Project. Otherwise returns an
    /// empty set of permissions.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.test_iam_permissions()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn test_iam_permissions(&self) -> super::builder::instance_admin::TestIamPermissions {
        super::builder::instance_admin::TestIamPermissions::new(self.inner.clone())
    }

    /// Gets information about a particular instance partition.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_instance_partition()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_instance_partition(&self) -> super::builder::instance_admin::GetInstancePartition {
        super::builder::instance_admin::GetInstancePartition::new(self.inner.clone())
    }

    /// Creates an instance partition and begins preparing it to be used. The
    /// returned long-running operation
    /// can be used to track the progress of preparing the new instance partition.
    /// The instance partition name is assigned by the caller. If the named
    /// instance partition already exists, `CreateInstancePartition` returns
    /// `ALREADY_EXISTS`.
    ///
    /// Immediately upon completion of this request:
    ///
    /// * The instance partition is readable via the API, with all requested
    ///   attributes but no allocated resources. Its state is `CREATING`.
    ///
    /// Until completion of the returned operation:
    ///
    /// * Cancelling the operation renders the instance partition immediately
    ///   unreadable via the API.
    /// * The instance partition can be deleted.
    /// * All other attempts to modify the instance partition are rejected.
    ///
    /// Upon completion of the returned operation:
    ///
    /// * Billing for all successfully-allocated resources begins (some types
    ///   may have lower than the requested levels).
    /// * Databases can start using this instance partition.
    /// * The instance partition's allocated resource levels are readable via the
    ///   API.
    /// * The instance partition's state becomes `READY`.
    ///
    /// The returned long-running operation will
    /// have a name of the format
    /// `<instance_partition_name>/operations/<operation_id>` and can be used to
    /// track creation of the instance partition.  The
    /// metadata field type is
    /// [CreateInstancePartitionMetadata][google.spanner.admin.instance.v1.CreateInstancePartitionMetadata].
    /// The response field type is
    /// [InstancePartition][google.spanner.admin.instance.v1.InstancePartition], if
    /// successful.
    ///
    /// [google.spanner.admin.instance.v1.CreateInstancePartitionMetadata]: crate::model::CreateInstancePartitionMetadata
    /// [google.spanner.admin.instance.v1.InstancePartition]: crate::model::InstancePartition
    ///
    /// # 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_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.create_instance_partition()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_instance_partition(
        &self,
    ) -> super::builder::instance_admin::CreateInstancePartition {
        super::builder::instance_admin::CreateInstancePartition::new(self.inner.clone())
    }

    /// Deletes an existing instance partition. Requires that the
    /// instance partition is not used by any database or backup and is not the
    /// default instance partition of an instance.
    ///
    /// Authorization requires `spanner.instancePartitions.delete` permission on
    /// the resource
    /// [name][google.spanner.admin.instance.v1.InstancePartition.name].
    ///
    /// [google.spanner.admin.instance.v1.InstancePartition.name]: crate::model::InstancePartition::name
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin, name: &str
    /// ) -> Result<()> {
    ///     client.delete_instance_partition()
    ///         .set_name(name)
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_instance_partition(
        &self,
    ) -> super::builder::instance_admin::DeleteInstancePartition {
        super::builder::instance_admin::DeleteInstancePartition::new(self.inner.clone())
    }

    /// Updates an instance partition, and begins allocating or releasing resources
    /// as requested. The returned long-running operation can be used to track the
    /// progress of updating the instance partition. If the named instance
    /// partition does not exist, returns `NOT_FOUND`.
    ///
    /// Immediately upon completion of this request:
    ///
    /// * For resource types for which a decrease in the instance partition's
    ///   allocation has been requested, billing is based on the newly-requested
    ///   level.
    ///
    /// Until completion of the returned operation:
    ///
    /// * Cancelling the operation sets its metadata's
    ///   [cancel_time][google.spanner.admin.instance.v1.UpdateInstancePartitionMetadata.cancel_time],
    ///   and begins restoring resources to their pre-request values. The
    ///   operation is guaranteed to succeed at undoing all resource changes,
    ///   after which point it terminates with a `CANCELLED` status.
    /// * All other attempts to modify the instance partition are rejected.
    /// * Reading the instance partition via the API continues to give the
    ///   pre-request resource levels.
    ///
    /// Upon completion of the returned operation:
    ///
    /// * Billing begins for all successfully-allocated resources (some types
    ///   may have lower than the requested levels).
    /// * All newly-reserved resources are available for serving the instance
    ///   partition's tables.
    /// * The instance partition's new resource levels are readable via the API.
    ///
    /// The returned long-running operation will
    /// have a name of the format
    /// `<instance_partition_name>/operations/<operation_id>` and can be used to
    /// track the instance partition modification. The
    /// metadata field type is
    /// [UpdateInstancePartitionMetadata][google.spanner.admin.instance.v1.UpdateInstancePartitionMetadata].
    /// The response field type is
    /// [InstancePartition][google.spanner.admin.instance.v1.InstancePartition], if
    /// successful.
    ///
    /// Authorization requires `spanner.instancePartitions.update` permission on
    /// the resource
    /// [name][google.spanner.admin.instance.v1.InstancePartition.name].
    ///
    /// [google.spanner.admin.instance.v1.InstancePartition]: crate::model::InstancePartition
    /// [google.spanner.admin.instance.v1.InstancePartition.name]: crate::model::InstancePartition::name
    /// [google.spanner.admin.instance.v1.UpdateInstancePartitionMetadata]: crate::model::UpdateInstancePartitionMetadata
    /// [google.spanner.admin.instance.v1.UpdateInstancePartitionMetadata.cancel_time]: crate::model::UpdateInstancePartitionMetadata::cancel_time
    ///
    /// # 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_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.update_instance_partition()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_instance_partition(
        &self,
    ) -> super::builder::instance_admin::UpdateInstancePartition {
        super::builder::instance_admin::UpdateInstancePartition::new(self.inner.clone())
    }

    /// Lists instance partition long-running operations in the given instance.
    /// An instance partition operation has a name of the form
    /// `projects/<project>/instances/<instance>/instancePartitions/<instance_partition>/operations/<operation>`.
    /// The long-running operation
    /// metadata field type
    /// `metadata.type_url` describes the type of the metadata. Operations returned
    /// include those that have completed/failed/canceled within the last 7 days,
    /// and pending operations. Operations returned are ordered by
    /// `operation.metadata.value.start_time` in descending order starting from the
    /// most recently started operation.
    ///
    /// Authorization requires `spanner.instancePartitionOperations.list`
    /// permission on the resource
    /// [parent][google.spanner.admin.instance.v1.ListInstancePartitionOperationsRequest.parent].
    ///
    /// [google.spanner.admin.instance.v1.ListInstancePartitionOperationsRequest.parent]: crate::model::ListInstancePartitionOperationsRequest::parent
    ///
    /// # Example
    /// ```
    /// # use google_cloud_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     let mut list = client.list_instance_partition_operations()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_instance_partition_operations(
        &self,
    ) -> super::builder::instance_admin::ListInstancePartitionOperations {
        super::builder::instance_admin::ListInstancePartitionOperations::new(self.inner.clone())
    }

    /// Moves an instance to the target instance configuration. You can use the
    /// returned long-running operation to track
    /// the progress of moving the instance.
    ///
    /// `MoveInstance` returns `FAILED_PRECONDITION` if the instance meets any of
    /// the following criteria:
    ///
    /// * Is undergoing a move to a different instance configuration
    /// * Has backups
    /// * Has an ongoing update
    /// * Contains any CMEK-enabled databases
    /// * Is a free trial instance
    ///
    /// While the operation is pending:
    ///
    /// * All other attempts to modify the instance, including changes to its
    ///   compute capacity, are rejected.
    ///
    /// * The following database and backup admin operations are rejected:
    ///
    ///   * `DatabaseAdmin.CreateDatabase`
    ///   * `DatabaseAdmin.UpdateDatabaseDdl` (disabled if default_leader is
    ///     specified in the request.)
    ///   * `DatabaseAdmin.RestoreDatabase`
    ///   * `DatabaseAdmin.CreateBackup`
    ///   * `DatabaseAdmin.CopyBackup`
    /// * Both the source and target instance configurations are subject to
    ///   hourly compute and storage charges.
    ///
    /// * The instance might experience higher read-write latencies and a higher
    ///   transaction abort rate. However, moving an instance doesn't cause any
    ///   downtime.
    ///
    ///
    /// The returned long-running operation has
    /// a name of the format
    /// `<instance_name>/operations/<operation_id>` and can be used to track
    /// the move instance operation. The
    /// metadata field type is
    /// [MoveInstanceMetadata][google.spanner.admin.instance.v1.MoveInstanceMetadata].
    /// The response field type is
    /// [Instance][google.spanner.admin.instance.v1.Instance],
    /// if successful.
    /// Cancelling the operation sets its metadata's
    /// [cancel_time][google.spanner.admin.instance.v1.MoveInstanceMetadata.cancel_time].
    /// Cancellation is not immediate because it involves moving any data
    /// previously moved to the target instance configuration back to the original
    /// instance configuration. You can use this operation to track the progress of
    /// the cancellation. Upon successful completion of the cancellation, the
    /// operation terminates with `CANCELLED` status.
    ///
    /// If not cancelled, upon completion of the returned operation:
    ///
    /// * The instance successfully moves to the target instance
    ///   configuration.
    /// * You are billed for compute and storage in target instance
    ///   configuration.
    ///
    /// Authorization requires the `spanner.instances.update` permission on
    /// the resource [instance][google.spanner.admin.instance.v1.Instance].
    ///
    /// For more details, see
    /// [Move an instance](https://cloud.google.com/spanner/docs/move-instance).
    ///
    /// [google.spanner.admin.instance.v1.Instance]: crate::model::Instance
    /// [google.spanner.admin.instance.v1.MoveInstanceMetadata]: crate::model::MoveInstanceMetadata
    /// [google.spanner.admin.instance.v1.MoveInstanceMetadata.cancel_time]: crate::model::MoveInstanceMetadata::cancel_time
    ///
    /// # 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_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.move_instance()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn move_instance(&self) -> super::builder::instance_admin::MoveInstance {
        super::builder::instance_admin::MoveInstance::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_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     let mut list = client.list_operations()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_operations(&self) -> super::builder::instance_admin::ListOperations {
        super::builder::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_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::instance_admin::GetOperation {
        super::builder::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_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::instance_admin::DeleteOperation {
        super::builder::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_spanner_admin_instance_v1::client::InstanceAdmin;
    /// use google_cloud_spanner_admin_instance_v1::Result;
    /// async fn sample(
    ///    client: &InstanceAdmin
    /// ) -> Result<()> {
    ///     client.cancel_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn cancel_operation(&self) -> super::builder::instance_admin::CancelOperation {
        super::builder::instance_admin::CancelOperation::new(self.inner.clone())
    }
}