google_cloud_vmwareengine_v1/

client.rs

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

/// Implements a client for the VMware Engine API.
///
/// # Example
/// ```
/// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
/// use google_cloud_gax::paginator::ItemPaginator as _;
/// # async fn sample() -> Result<(), Box<dyn std::error::Error>> {
///     let client = VmwareEngine::builder().build().await?;
///     let parent = "parent_value";
///     let mut list = client.list_vmware_engine_networks()
///         .set_parent(parent)
///         .by_item();
///     while let Some(item) = list.next().await.transpose()? {
///         println!("{:?}", item);
///     }
/// # Ok(()) }
/// ```
///
/// # Service Description
///
/// VMwareEngine manages VMware's private clusters in the Cloud.
///
/// # Configuration
///
/// To configure `VmwareEngine` use the `with_*` methods in the type returned
/// by [builder()][VmwareEngine::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://vmwareengine.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::vmware_engine::ClientBuilder::with_endpoint
/// [with_credentials()]: super::builder::vmware_engine::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
///
/// `VmwareEngine` holds a connection pool internally, it is advised to
/// create one and reuse it. You do not need to wrap `VmwareEngine` 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 VmwareEngine {
    inner: std::sync::Arc<dyn super::stub::dynamic::VmwareEngine>,
}

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

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

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

    /// Retrieves a `PrivateCloud` resource by its resource name.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_private_cloud()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_private_cloud(&self) -> super::builder::vmware_engine::GetPrivateCloud {
        super::builder::vmware_engine::GetPrivateCloud::new(self.inner.clone())
    }

    /// Creates a new `PrivateCloud` resource in a given project and location.
    /// Private clouds of type `STANDARD` and
    /// `TIME_LIMITED` are zonal resources, `STRETCHED` private clouds are
    /// regional.
    /// Creating a private cloud also creates a [management
    /// cluster](https://cloud.google.com/vmware-engine/docs/concepts-vmware-components)
    /// for that private cloud.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::model::PrivateCloud;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_private_cloud()
    ///         .set_parent(parent)
    ///         .set_private_cloud(
    ///             PrivateCloud::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_private_cloud(&self) -> super::builder::vmware_engine::CreatePrivateCloud {
        super::builder::vmware_engine::CreatePrivateCloud::new(self.inner.clone())
    }

    /// Modifies a `PrivateCloud` resource. Only the following fields can be
    /// updated: `description`.
    /// Only fields specified in `updateMask` are applied.
    ///
    /// During operation processing, the resource is temporarily in the `ACTIVE`
    /// state before the operation fully completes. For that period of time, you
    /// can't update the resource. Use the operation status to determine when the
    /// processing fully completes.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_vmwareengine_v1::model::PrivateCloud;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.update_private_cloud()
    ///         .set_private_cloud(
    ///             PrivateCloud::new().set_name(name)/* 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_private_cloud(&self) -> super::builder::vmware_engine::UpdatePrivateCloud {
        super::builder::vmware_engine::UpdatePrivateCloud::new(self.inner.clone())
    }

    /// Schedules a `PrivateCloud` resource for deletion.
    ///
    /// A `PrivateCloud` resource scheduled for deletion has `PrivateCloud.state`
    /// set to `DELETED` and `expireTime` set to the time when deletion is final
    /// and can no longer be reversed. The delete operation is marked as done
    /// as soon as the `PrivateCloud` is successfully scheduled for deletion
    /// (this also applies when `delayHours` is set to zero), and the operation is
    /// not kept in pending state until `PrivateCloud` is purged.
    /// `PrivateCloud` can be restored using `UndeletePrivateCloud` method before
    /// the `expireTime` elapses. When `expireTime` is reached, deletion is final
    /// and all private cloud resources are irreversibly removed and billing stops.
    /// During the final removal process, `PrivateCloud.state` is set to `PURGING`.
    /// `PrivateCloud` can be polled using standard `GET` method for the whole
    /// period of deletion and purging. It will not be returned only
    /// when it is completely purged.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.delete_private_cloud()
    ///         .set_name(name)
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_private_cloud(&self) -> super::builder::vmware_engine::DeletePrivateCloud {
        super::builder::vmware_engine::DeletePrivateCloud::new(self.inner.clone())
    }

    /// Restores a private cloud that was previously scheduled for deletion by
    /// `DeletePrivateCloud`. A `PrivateCloud` resource scheduled for deletion has
    /// `PrivateCloud.state` set to `DELETED` and `PrivateCloud.expireTime` set to
    /// the time when deletion can no longer be reversed.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.undelete_private_cloud()
    ///         .set_name(name)
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn undelete_private_cloud(&self) -> super::builder::vmware_engine::UndeletePrivateCloud {
        super::builder::vmware_engine::UndeletePrivateCloud::new(self.inner.clone())
    }

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

    /// Retrieves a `Cluster` resource by its resource name.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_cluster()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_cluster(&self) -> super::builder::vmware_engine::GetCluster {
        super::builder::vmware_engine::GetCluster::new(self.inner.clone())
    }

    /// Creates a new cluster in a given private cloud.
    /// Creating a new cluster provides additional nodes for
    /// use in the parent private cloud and requires sufficient [node
    /// quota](https://cloud.google.com/vmware-engine/quotas).
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::model::Cluster;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_cluster()
    ///         .set_parent(parent)
    ///         .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::vmware_engine::CreateCluster {
        super::builder::vmware_engine::CreateCluster::new(self.inner.clone())
    }

    /// Modifies a `Cluster` resource. Only fields specified in `updateMask` are
    /// applied.
    ///
    /// During operation processing, the resource is temporarily in the `ACTIVE`
    /// state before the operation fully completes. For that period of time, you
    /// can't update the resource. Use the operation status to determine when the
    /// processing fully completes.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_vmwareengine_v1::model::Cluster;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.update_cluster()
    ///         .set_cluster(
    ///             Cluster::new().set_name(name)/* set fields */
    ///         )
    ///         .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn update_cluster(&self) -> super::builder::vmware_engine::UpdateCluster {
        super::builder::vmware_engine::UpdateCluster::new(self.inner.clone())
    }

    /// Deletes a `Cluster` resource. To avoid unintended data loss, migrate or
    /// gracefully shut down any workloads running on the cluster before deletion.
    /// You cannot delete the management cluster of a private cloud using this
    /// method.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     client.delete_cluster()
    ///         .set_name(name)
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_cluster(&self) -> super::builder::vmware_engine::DeleteCluster {
        super::builder::vmware_engine::DeleteCluster::new(self.inner.clone())
    }

    /// Lists nodes in a given cluster.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_nodes()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_nodes(&self) -> super::builder::vmware_engine::ListNodes {
        super::builder::vmware_engine::ListNodes::new(self.inner.clone())
    }

    /// Gets details of a single node.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_node()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_node(&self) -> super::builder::vmware_engine::GetNode {
        super::builder::vmware_engine::GetNode::new(self.inner.clone())
    }

    /// Lists external IP addresses assigned to VMware workload VMs in a given
    /// private cloud.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_external_addresses()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_external_addresses(&self) -> super::builder::vmware_engine::ListExternalAddresses {
        super::builder::vmware_engine::ListExternalAddresses::new(self.inner.clone())
    }

    /// Lists external IP addresses assigned to VMware workload VMs within the
    /// scope of the given network policy.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let mut list = client.fetch_network_policy_external_addresses()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn fetch_network_policy_external_addresses(
        &self,
    ) -> super::builder::vmware_engine::FetchNetworkPolicyExternalAddresses {
        super::builder::vmware_engine::FetchNetworkPolicyExternalAddresses::new(self.inner.clone())
    }

    /// Gets details of a single external IP address.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_external_address()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_external_address(&self) -> super::builder::vmware_engine::GetExternalAddress {
        super::builder::vmware_engine::GetExternalAddress::new(self.inner.clone())
    }

    /// Creates a new `ExternalAddress` resource in a given private cloud. The
    /// network policy that corresponds to the private cloud must have the external
    /// IP address network service enabled (`NetworkPolicy.external_ip`).
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::model::ExternalAddress;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_external_address()
    ///         .set_parent(parent)
    ///         .set_external_address(
    ///             ExternalAddress::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_external_address(&self) -> super::builder::vmware_engine::CreateExternalAddress {
        super::builder::vmware_engine::CreateExternalAddress::new(self.inner.clone())
    }

    /// Updates the parameters of a single external IP address.
    /// Only fields specified in `update_mask` are applied.
    ///
    /// During operation processing, the resource is temporarily in the `ACTIVE`
    /// state before the operation fully completes. For that period of time, you
    /// can't update the resource. Use the operation status to determine when the
    /// processing fully completes.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_vmwareengine_v1::model::ExternalAddress;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.update_external_address()
    ///         .set_external_address(
    ///             ExternalAddress::new().set_name(name)/* 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_external_address(&self) -> super::builder::vmware_engine::UpdateExternalAddress {
        super::builder::vmware_engine::UpdateExternalAddress::new(self.inner.clone())
    }

    /// Deletes a single external IP address. When you delete an external IP
    /// address, connectivity between the external IP address and the corresponding
    /// internal IP address is lost.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     client.delete_external_address()
    ///         .set_name(name)
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_external_address(&self) -> super::builder::vmware_engine::DeleteExternalAddress {
        super::builder::vmware_engine::DeleteExternalAddress::new(self.inner.clone())
    }

    /// Lists subnets in a given private cloud.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_subnets()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_subnets(&self) -> super::builder::vmware_engine::ListSubnets {
        super::builder::vmware_engine::ListSubnets::new(self.inner.clone())
    }

    /// Gets details of a single subnet.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_subnet()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_subnet(&self) -> super::builder::vmware_engine::GetSubnet {
        super::builder::vmware_engine::GetSubnet::new(self.inner.clone())
    }

    /// Updates the parameters of a single subnet. Only fields specified in
    /// `update_mask` are applied.
    ///
    /// *Note*: This API is synchronous and always returns a successful
    /// `google.longrunning.Operation` (LRO). The returned LRO will only have
    /// `done` and `response` fields.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_vmwareengine_v1::model::Subnet;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.update_subnet()
    ///         .set_subnet(
    ///             Subnet::new().set_name(name)/* 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_subnet(&self) -> super::builder::vmware_engine::UpdateSubnet {
        super::builder::vmware_engine::UpdateSubnet::new(self.inner.clone())
    }

    /// Lists `ExternalAccessRule` resources in the specified network policy.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_external_access_rules()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_external_access_rules(
        &self,
    ) -> super::builder::vmware_engine::ListExternalAccessRules {
        super::builder::vmware_engine::ListExternalAccessRules::new(self.inner.clone())
    }

    /// Gets details of a single external access rule.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_external_access_rule()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_external_access_rule(&self) -> super::builder::vmware_engine::GetExternalAccessRule {
        super::builder::vmware_engine::GetExternalAccessRule::new(self.inner.clone())
    }

    /// Creates a new external access rule in a given network 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::model::ExternalAccessRule;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_external_access_rule()
    ///         .set_parent(parent)
    ///         .set_external_access_rule(
    ///             ExternalAccessRule::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_external_access_rule(
        &self,
    ) -> super::builder::vmware_engine::CreateExternalAccessRule {
        super::builder::vmware_engine::CreateExternalAccessRule::new(self.inner.clone())
    }

    /// Updates the parameters of a single external access rule.
    /// Only fields specified in `update_mask` are applied.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_vmwareengine_v1::model::ExternalAccessRule;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.update_external_access_rule()
    ///         .set_external_access_rule(
    ///             ExternalAccessRule::new().set_name(name)/* 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_external_access_rule(
        &self,
    ) -> super::builder::vmware_engine::UpdateExternalAccessRule {
        super::builder::vmware_engine::UpdateExternalAccessRule::new(self.inner.clone())
    }

    /// Deletes a single external access rule.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     client.delete_external_access_rule()
    ///         .set_name(name)
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_external_access_rule(
        &self,
    ) -> super::builder::vmware_engine::DeleteExternalAccessRule {
        super::builder::vmware_engine::DeleteExternalAccessRule::new(self.inner.clone())
    }

    /// Lists logging servers configured for a given private
    /// cloud.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_logging_servers()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_logging_servers(&self) -> super::builder::vmware_engine::ListLoggingServers {
        super::builder::vmware_engine::ListLoggingServers::new(self.inner.clone())
    }

    /// Gets details of a logging server.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_logging_server()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_logging_server(&self) -> super::builder::vmware_engine::GetLoggingServer {
        super::builder::vmware_engine::GetLoggingServer::new(self.inner.clone())
    }

    /// Create a new logging server for a given private cloud.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::model::LoggingServer;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_logging_server()
    ///         .set_parent(parent)
    ///         .set_logging_server(
    ///             LoggingServer::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_logging_server(&self) -> super::builder::vmware_engine::CreateLoggingServer {
        super::builder::vmware_engine::CreateLoggingServer::new(self.inner.clone())
    }

    /// Updates the parameters of a single logging server.
    /// Only fields specified in `update_mask` are applied.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_vmwareengine_v1::model::LoggingServer;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.update_logging_server()
    ///         .set_logging_server(
    ///             LoggingServer::new().set_name(name)/* 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_logging_server(&self) -> super::builder::vmware_engine::UpdateLoggingServer {
        super::builder::vmware_engine::UpdateLoggingServer::new(self.inner.clone())
    }

    /// Deletes a single logging server.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     client.delete_logging_server()
    ///         .set_name(name)
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_logging_server(&self) -> super::builder::vmware_engine::DeleteLoggingServer {
        super::builder::vmware_engine::DeleteLoggingServer::new(self.inner.clone())
    }

    /// Lists node types
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_node_types()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_node_types(&self) -> super::builder::vmware_engine::ListNodeTypes {
        super::builder::vmware_engine::ListNodeTypes::new(self.inner.clone())
    }

    /// Gets details of a single `NodeType`.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_node_type()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_node_type(&self) -> super::builder::vmware_engine::GetNodeType {
        super::builder::vmware_engine::GetNodeType::new(self.inner.clone())
    }

    /// Gets details of credentials for NSX appliance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let response = client.show_nsx_credentials()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn show_nsx_credentials(&self) -> super::builder::vmware_engine::ShowNsxCredentials {
        super::builder::vmware_engine::ShowNsxCredentials::new(self.inner.clone())
    }

    /// Gets details of credentials for Vcenter appliance.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let response = client.show_vcenter_credentials()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn show_vcenter_credentials(
        &self,
    ) -> super::builder::vmware_engine::ShowVcenterCredentials {
        super::builder::vmware_engine::ShowVcenterCredentials::new(self.inner.clone())
    }

    /// Resets credentials of the NSX appliance.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let response = client.reset_nsx_credentials()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn reset_nsx_credentials(&self) -> super::builder::vmware_engine::ResetNsxCredentials {
        super::builder::vmware_engine::ResetNsxCredentials::new(self.inner.clone())
    }

    /// Resets credentials of the Vcenter appliance.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let response = client.reset_vcenter_credentials()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn reset_vcenter_credentials(
        &self,
    ) -> super::builder::vmware_engine::ResetVcenterCredentials {
        super::builder::vmware_engine::ResetVcenterCredentials::new(self.inner.clone())
    }

    /// Gets details of the `DnsForwarding` config.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_dns_forwarding()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_dns_forwarding(&self) -> super::builder::vmware_engine::GetDnsForwarding {
        super::builder::vmware_engine::GetDnsForwarding::new(self.inner.clone())
    }

    /// Updates the parameters of the `DnsForwarding` config, like associated
    /// domains. Only fields specified in `update_mask` are applied.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_vmwareengine_v1::model::DnsForwarding;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.update_dns_forwarding()
    ///         .set_dns_forwarding(
    ///             DnsForwarding::new().set_name(name)/* 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_dns_forwarding(&self) -> super::builder::vmware_engine::UpdateDnsForwarding {
        super::builder::vmware_engine::UpdateDnsForwarding::new(self.inner.clone())
    }

    /// Retrieves a `NetworkPeering` resource by its resource name. The resource
    /// contains details of the network peering, such as peered
    /// networks, import and export custom route configurations, and peering state.
    /// NetworkPeering is a global resource and location can only be global.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_network_peering()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_network_peering(&self) -> super::builder::vmware_engine::GetNetworkPeering {
        super::builder::vmware_engine::GetNetworkPeering::new(self.inner.clone())
    }

    /// Lists `NetworkPeering` resources in a given project. NetworkPeering is a
    /// global resource and location can only be global.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_network_peerings()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_network_peerings(&self) -> super::builder::vmware_engine::ListNetworkPeerings {
        super::builder::vmware_engine::ListNetworkPeerings::new(self.inner.clone())
    }

    /// Creates a new network peering between the peer network and VMware Engine
    /// network provided in a `NetworkPeering` resource. NetworkPeering is a
    /// global resource and location can only be global.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::model::NetworkPeering;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_network_peering()
    ///         .set_parent(parent)
    ///         .set_network_peering(
    ///             NetworkPeering::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_network_peering(&self) -> super::builder::vmware_engine::CreateNetworkPeering {
        super::builder::vmware_engine::CreateNetworkPeering::new(self.inner.clone())
    }

    /// Deletes a `NetworkPeering` resource. When a network peering is deleted for
    /// a VMware Engine network, the peer network becomes inaccessible to that
    /// VMware Engine network. NetworkPeering is a global resource and location can
    /// only be global.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     client.delete_network_peering()
    ///         .set_name(name)
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_network_peering(&self) -> super::builder::vmware_engine::DeleteNetworkPeering {
        super::builder::vmware_engine::DeleteNetworkPeering::new(self.inner.clone())
    }

    /// Modifies a `NetworkPeering` resource. Only the `description` field can be
    /// updated. Only fields specified in `updateMask` are applied. NetworkPeering
    /// is a global resource and location can only be global.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_vmwareengine_v1::model::NetworkPeering;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.update_network_peering()
    ///         .set_network_peering(
    ///             NetworkPeering::new().set_name(name)/* 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_network_peering(&self) -> super::builder::vmware_engine::UpdateNetworkPeering {
        super::builder::vmware_engine::UpdateNetworkPeering::new(self.inner.clone())
    }

    /// Lists the network peering routes exchanged over a peering connection.
    /// NetworkPeering is a global resource and location can only be global.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let mut list = client.list_peering_routes()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_peering_routes(&self) -> super::builder::vmware_engine::ListPeeringRoutes {
        super::builder::vmware_engine::ListPeeringRoutes::new(self.inner.clone())
    }

    /// Creates a new HCX activation key in a given private cloud.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::model::HcxActivationKey;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_hcx_activation_key()
    ///         .set_parent(parent)
    ///         .set_hcx_activation_key(
    ///             HcxActivationKey::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_hcx_activation_key(
        &self,
    ) -> super::builder::vmware_engine::CreateHcxActivationKey {
        super::builder::vmware_engine::CreateHcxActivationKey::new(self.inner.clone())
    }

    /// Lists `HcxActivationKey` resources in a given private cloud.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_hcx_activation_keys()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_hcx_activation_keys(&self) -> super::builder::vmware_engine::ListHcxActivationKeys {
        super::builder::vmware_engine::ListHcxActivationKeys::new(self.inner.clone())
    }

    /// Retrieves a `HcxActivationKey` resource by its resource name.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_hcx_activation_key()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_hcx_activation_key(&self) -> super::builder::vmware_engine::GetHcxActivationKey {
        super::builder::vmware_engine::GetHcxActivationKey::new(self.inner.clone())
    }

    /// Retrieves a `NetworkPolicy` resource by its resource name.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_network_policy()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_network_policy(&self) -> super::builder::vmware_engine::GetNetworkPolicy {
        super::builder::vmware_engine::GetNetworkPolicy::new(self.inner.clone())
    }

    /// Lists `NetworkPolicy` resources in a specified project and location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_network_policies()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_network_policies(&self) -> super::builder::vmware_engine::ListNetworkPolicies {
        super::builder::vmware_engine::ListNetworkPolicies::new(self.inner.clone())
    }

    /// Creates a new network policy in a given VMware Engine network of a
    /// project and location (region). A new network policy cannot be created if
    /// another network policy already exists in the same scope.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::model::NetworkPolicy;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_network_policy()
    ///         .set_parent(parent)
    ///         .set_network_policy(
    ///             NetworkPolicy::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_network_policy(&self) -> super::builder::vmware_engine::CreateNetworkPolicy {
        super::builder::vmware_engine::CreateNetworkPolicy::new(self.inner.clone())
    }

    /// Modifies a `NetworkPolicy` resource. Only the following fields can be
    /// updated: `internet_access`, `external_ip`, `edge_services_cidr`.
    /// Only fields specified in `updateMask` are applied. When updating a network
    /// policy, the external IP network service can only be disabled if there are
    /// no external IP addresses present in the scope of the policy. Also, a
    /// `NetworkService` cannot be updated when `NetworkService.state` is set
    /// to `RECONCILING`.
    ///
    /// During operation processing, the resource is temporarily in the `ACTIVE`
    /// state before the operation fully completes. For that period of time, you
    /// can't update the resource. Use the operation status to determine when the
    /// processing fully completes.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_vmwareengine_v1::model::NetworkPolicy;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.update_network_policy()
    ///         .set_network_policy(
    ///             NetworkPolicy::new().set_name(name)/* 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_network_policy(&self) -> super::builder::vmware_engine::UpdateNetworkPolicy {
        super::builder::vmware_engine::UpdateNetworkPolicy::new(self.inner.clone())
    }

    /// Deletes a `NetworkPolicy` resource. A network policy cannot be deleted
    /// when `NetworkService.state` is set to `RECONCILING` for either its external
    /// IP or internet access service.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     client.delete_network_policy()
    ///         .set_name(name)
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_network_policy(&self) -> super::builder::vmware_engine::DeleteNetworkPolicy {
        super::builder::vmware_engine::DeleteNetworkPolicy::new(self.inner.clone())
    }

    /// Lists Consumer VPCs bound to Management DNS Zone of a given private cloud.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let mut list = client.list_management_dns_zone_bindings()
    ///         .set_parent(parent)
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_management_dns_zone_bindings(
        &self,
    ) -> super::builder::vmware_engine::ListManagementDnsZoneBindings {
        super::builder::vmware_engine::ListManagementDnsZoneBindings::new(self.inner.clone())
    }

    /// Retrieves a 'ManagementDnsZoneBinding' resource by its resource name.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_management_dns_zone_binding()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_management_dns_zone_binding(
        &self,
    ) -> super::builder::vmware_engine::GetManagementDnsZoneBinding {
        super::builder::vmware_engine::GetManagementDnsZoneBinding::new(self.inner.clone())
    }

    /// Creates a new `ManagementDnsZoneBinding` resource in a private cloud.
    /// This RPC creates the DNS binding and the resource that represents the
    /// DNS binding of the consumer VPC network to the management DNS zone. A
    /// management DNS zone is the Cloud DNS cross-project binding zone that
    /// VMware Engine creates for each private cloud. It contains FQDNs and
    /// corresponding IP addresses for the private cloud's ESXi hosts and
    /// management VM appliances like vCenter and NSX Manager.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::model::ManagementDnsZoneBinding;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_management_dns_zone_binding()
    ///         .set_parent(parent)
    ///         .set_management_dns_zone_binding(
    ///             ManagementDnsZoneBinding::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_management_dns_zone_binding(
        &self,
    ) -> super::builder::vmware_engine::CreateManagementDnsZoneBinding {
        super::builder::vmware_engine::CreateManagementDnsZoneBinding::new(self.inner.clone())
    }

    /// Updates a `ManagementDnsZoneBinding` resource.
    /// Only fields specified in `update_mask` are applied.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_vmwareengine_v1::model::ManagementDnsZoneBinding;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.update_management_dns_zone_binding()
    ///         .set_management_dns_zone_binding(
    ///             ManagementDnsZoneBinding::new().set_name(name)/* 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_management_dns_zone_binding(
        &self,
    ) -> super::builder::vmware_engine::UpdateManagementDnsZoneBinding {
        super::builder::vmware_engine::UpdateManagementDnsZoneBinding::new(self.inner.clone())
    }

    /// Deletes a `ManagementDnsZoneBinding` resource. When a management DNS zone
    /// binding is deleted, the corresponding consumer VPC network is no longer
    /// bound to the management DNS zone.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     client.delete_management_dns_zone_binding()
    ///         .set_name(name)
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_management_dns_zone_binding(
        &self,
    ) -> super::builder::vmware_engine::DeleteManagementDnsZoneBinding {
        super::builder::vmware_engine::DeleteManagementDnsZoneBinding::new(self.inner.clone())
    }

    /// Retries to create a `ManagementDnsZoneBinding` resource that is
    /// in failed state.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let response = client.repair_management_dns_zone_binding()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn repair_management_dns_zone_binding(
        &self,
    ) -> super::builder::vmware_engine::RepairManagementDnsZoneBinding {
        super::builder::vmware_engine::RepairManagementDnsZoneBinding::new(self.inner.clone())
    }

    /// Creates a new VMware Engine network that can be used by a private cloud.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::model::VmwareEngineNetwork;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_vmware_engine_network()
    ///         .set_parent(parent)
    ///         .set_vmware_engine_network(
    ///             VmwareEngineNetwork::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_vmware_engine_network(
        &self,
    ) -> super::builder::vmware_engine::CreateVmwareEngineNetwork {
        super::builder::vmware_engine::CreateVmwareEngineNetwork::new(self.inner.clone())
    }

    /// Modifies a VMware Engine network resource. Only the following fields can be
    /// updated: `description`. Only fields specified in `updateMask` are
    /// applied.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_vmwareengine_v1::model::VmwareEngineNetwork;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.update_vmware_engine_network()
    ///         .set_vmware_engine_network(
    ///             VmwareEngineNetwork::new().set_name(name)/* 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_vmware_engine_network(
        &self,
    ) -> super::builder::vmware_engine::UpdateVmwareEngineNetwork {
        super::builder::vmware_engine::UpdateVmwareEngineNetwork::new(self.inner.clone())
    }

    /// Deletes a `VmwareEngineNetwork` resource. You can only delete a VMware
    /// Engine network after all resources that refer to it are deleted. For
    /// example, a private cloud, a network peering, and a network policy can all
    /// refer to the same VMware Engine network.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     client.delete_vmware_engine_network()
    ///         .set_name(name)
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_vmware_engine_network(
        &self,
    ) -> super::builder::vmware_engine::DeleteVmwareEngineNetwork {
        super::builder::vmware_engine::DeleteVmwareEngineNetwork::new(self.inner.clone())
    }

    /// Retrieves a `VmwareEngineNetwork` resource by its resource name. The
    /// resource contains details of the VMware Engine network, such as its VMware
    /// Engine network type, peered networks in a service project, and state
    /// (for example, `CREATING`, `ACTIVE`, `DELETING`).
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_vmware_engine_network()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_vmware_engine_network(
        &self,
    ) -> super::builder::vmware_engine::GetVmwareEngineNetwork {
        super::builder::vmware_engine::GetVmwareEngineNetwork::new(self.inner.clone())
    }

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

    /// Creates a new private connection that can be used for accessing private
    /// Clouds.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::model::PrivateConnection;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, parent: &str
    /// ) -> Result<()> {
    ///     let response = client.create_private_connection()
    ///         .set_parent(parent)
    ///         .set_private_connection(
    ///             PrivateConnection::new()/* set fields */
    ///         )
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn create_private_connection(
        &self,
    ) -> super::builder::vmware_engine::CreatePrivateConnection {
        super::builder::vmware_engine::CreatePrivateConnection::new(self.inner.clone())
    }

    /// Retrieves a `PrivateConnection` resource by its resource name. The resource
    /// contains details of the private connection, such as connected
    /// network, routing mode and state.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_private_connection()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_private_connection(&self) -> super::builder::vmware_engine::GetPrivateConnection {
        super::builder::vmware_engine::GetPrivateConnection::new(self.inner.clone())
    }

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

    /// Modifies a `PrivateConnection` resource. Only `description` and
    /// `routing_mode` fields can be updated. Only fields specified in `updateMask`
    /// are applied.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// # extern crate wkt as google_cloud_wkt;
    /// use google_cloud_wkt::FieldMask;
    /// use google_cloud_vmwareengine_v1::model::PrivateConnection;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.update_private_connection()
    ///         .set_private_connection(
    ///             PrivateConnection::new().set_name(name)/* 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_private_connection(
        &self,
    ) -> super::builder::vmware_engine::UpdatePrivateConnection {
        super::builder::vmware_engine::UpdatePrivateConnection::new(self.inner.clone())
    }

    /// Deletes a `PrivateConnection` resource. When a private connection is
    /// deleted for a VMware Engine network, the connected network becomes
    /// inaccessible to that VMware Engine network.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     client.delete_private_connection()
    ///         .set_name(name)
    ///         .poller().until_done().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_private_connection(
        &self,
    ) -> super::builder::vmware_engine::DeletePrivateConnection {
        super::builder::vmware_engine::DeletePrivateConnection::new(self.inner.clone())
    }

    /// Lists the private connection routes exchanged over a peering connection.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let mut list = client.list_private_connection_peering_routes()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_private_connection_peering_routes(
        &self,
    ) -> super::builder::vmware_engine::ListPrivateConnectionPeeringRoutes {
        super::builder::vmware_engine::ListPrivateConnectionPeeringRoutes::new(self.inner.clone())
    }

    /// Grants the bind permission to the customer provided principal(user /
    /// service account) to bind their DNS zone with the intranet VPC associated
    /// with the project. DnsBindPermission is a global resource and location can
    /// only be global.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let response = client.grant_dns_bind_permission()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn grant_dns_bind_permission(
        &self,
    ) -> super::builder::vmware_engine::GrantDnsBindPermission {
        super::builder::vmware_engine::GrantDnsBindPermission::new(self.inner.clone())
    }

    /// Gets all the principals having bind permission on the intranet VPC
    /// associated with the consumer project granted by the Grant API.
    /// DnsBindPermission is a global resource and location can only be global.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine, name: &str
    /// ) -> Result<()> {
    ///     let response = client.get_dns_bind_permission()
    ///         .set_name(name)
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_dns_bind_permission(&self) -> super::builder::vmware_engine::GetDnsBindPermission {
        super::builder::vmware_engine::GetDnsBindPermission::new(self.inner.clone())
    }

    /// Revokes the bind permission from the customer provided principal(user /
    /// service account) on the intranet VPC associated with the consumer project.
    /// DnsBindPermission is a global resource and location can only be global.
    ///
    /// # 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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_lro::Poller;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let response = client.revoke_dns_bind_permission()
    ///         /* set fields */
    ///         .poller().until_done().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn revoke_dns_bind_permission(
        &self,
    ) -> super::builder::vmware_engine::RevokeDnsBindPermission {
        super::builder::vmware_engine::RevokeDnsBindPermission::new(self.inner.clone())
    }

    /// Lists information about the supported locations for this service.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let mut list = client.list_locations()
    ///         /* set fields */
    ///         .by_item();
    ///     while let Some(item) = list.next().await.transpose()? {
    ///         println!("{:?}", item);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    pub fn list_locations(&self) -> super::builder::vmware_engine::ListLocations {
        super::builder::vmware_engine::ListLocations::new(self.inner.clone())
    }

    /// Gets information about a location.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let response = client.get_location()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_location(&self) -> super::builder::vmware_engine::GetLocation {
        super::builder::vmware_engine::GetLocation::new(self.inner.clone())
    }

    /// Sets the access control policy on the specified resource. Replaces
    /// any existing policy.
    ///
    /// Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED`
    /// errors.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let response = client.set_iam_policy()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn set_iam_policy(&self) -> super::builder::vmware_engine::SetIamPolicy {
        super::builder::vmware_engine::SetIamPolicy::new(self.inner.clone())
    }

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

    /// Returns permissions that a caller has on the specified resource. If the
    /// resource does not exist, this will return an empty set of
    /// permissions, not a `NOT_FOUND` error.
    ///
    /// Note: This operation is designed to be used for building
    /// permission-aware UIs and command-line tools, not for authorization
    /// checking. This operation may "fail open" without warning.
    ///
    /// # Example
    /// ```
    /// # use google_cloud_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let response = client.test_iam_permissions()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn test_iam_permissions(&self) -> super::builder::vmware_engine::TestIamPermissions {
        super::builder::vmware_engine::TestIamPermissions::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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_gax::paginator::ItemPaginator as _;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> 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::vmware_engine::ListOperations {
        super::builder::vmware_engine::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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     let response = client.get_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     println!("response {:?}", response);
    ///     Ok(())
    /// }
    /// ```
    pub fn get_operation(&self) -> super::builder::vmware_engine::GetOperation {
        super::builder::vmware_engine::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_vmwareengine_v1::client::VmwareEngine;
    /// use google_cloud_vmwareengine_v1::Result;
    /// async fn sample(
    ///    client: &VmwareEngine
    /// ) -> Result<()> {
    ///     client.delete_operation()
    ///         /* set fields */
    ///         .send().await?;
    ///     Ok(())
    /// }
    /// ```
    pub fn delete_operation(&self) -> super::builder::vmware_engine::DeleteOperation {
        super::builder::vmware_engine::DeleteOperation::new(self.inner.clone())
    }
}