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)]

use crate::Result;
use std::sync::Arc;

/// Implements a client for the VMware Engine API.
///
/// # Service Description
///
/// VMwareEngine manages VMware's private clusters in the Cloud.
///
/// # Configuration
///
/// `VmwareEngine` has various configuration parameters, the defaults should
/// work with most applications.
///
/// # Pooling and Cloning
///
/// `VmwareEngine` holds a connection pool internally, it is advised to
/// create one and the reuse it.  You do not need to wrap `VmwareEngine` in
/// an [Rc](std::rc::Rc) or [Arc] to reuse it, because it already uses an `Arc`
/// internally.
#[derive(Clone, Debug)]
pub struct VmwareEngine {
    inner: Arc<dyn crate::stubs::dynamic::VmwareEngine>,
}

impl VmwareEngine {
    /// Creates a new client with the default configuration.
    pub async fn new() -> Result<Self> {
        Self::new_with_config(gax::options::ClientConfig::default()).await
    }

    /// Creates a new client with the specified configuration.
    pub async fn new_with_config(conf: gax::options::ClientConfig) -> Result<Self> {
        let inner = Self::build_inner(conf).await?;
        Ok(Self { inner })
    }

    /// Creates a new client from the provided stub.
    ///
    /// The most common case for calling this function is when mocking the
    /// client.
    pub fn from_stub<T>(stub: T) -> Self
    where
        T: crate::stubs::VmwareEngine + 'static,
    {
        Self {
            inner: Arc::new(stub),
        }
    }

    async fn build_inner(
        conf: gax::options::ClientConfig,
    ) -> Result<Arc<dyn crate::stubs::dynamic::VmwareEngine>> {
        if conf.tracing_enabled() {
            return Ok(Arc::new(Self::build_with_tracing(conf).await?));
        }
        Ok(Arc::new(Self::build_transport(conf).await?))
    }

    async fn build_transport(
        conf: gax::options::ClientConfig,
    ) -> Result<impl crate::stubs::VmwareEngine> {
        crate::transport::VmwareEngine::new(conf).await
    }

    async fn build_with_tracing(
        conf: gax::options::ClientConfig,
    ) -> Result<impl crate::stubs::VmwareEngine> {
        Self::build_transport(conf)
            .await
            .map(crate::tracing::VmwareEngine::new)
    }

    /// Lists `PrivateCloud` resources in a given project and location.
    pub fn list_private_clouds(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListPrivateClouds {
        crate::builders::vmware_engine::ListPrivateClouds::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// Retrieves a `PrivateCloud` resource by its resource name.
    pub fn get_private_cloud(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetPrivateCloud {
        crate::builders::vmware_engine::GetPrivateCloud::new(self.inner.clone())
            .set_name(name.into())
    }

    /// 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
    pub fn create_private_cloud(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::CreatePrivateCloud {
        crate::builders::vmware_engine::CreatePrivateCloud::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn update_private_cloud(
        &self,
        private_cloud: impl Into<crate::model::PrivateCloud>,
    ) -> crate::builders::vmware_engine::UpdatePrivateCloud {
        crate::builders::vmware_engine::UpdatePrivateCloud::new(self.inner.clone())
            .set_private_cloud(private_cloud.into())
    }

    /// 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
    pub fn delete_private_cloud(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::DeletePrivateCloud {
        crate::builders::vmware_engine::DeletePrivateCloud::new(self.inner.clone())
            .set_name(name.into())
    }

    /// 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
    pub fn undelete_private_cloud(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::UndeletePrivateCloud {
        crate::builders::vmware_engine::UndeletePrivateCloud::new(self.inner.clone())
            .set_name(name.into())
    }

    /// Lists `Cluster` resources in a given private cloud.
    pub fn list_clusters(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListClusters {
        crate::builders::vmware_engine::ListClusters::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// Retrieves a `Cluster` resource by its resource name.
    pub fn get_cluster(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetCluster {
        crate::builders::vmware_engine::GetCluster::new(self.inner.clone()).set_name(name.into())
    }

    /// 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
    pub fn create_cluster(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::CreateCluster {
        crate::builders::vmware_engine::CreateCluster::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn update_cluster(
        &self,
        cluster: impl Into<crate::model::Cluster>,
    ) -> crate::builders::vmware_engine::UpdateCluster {
        crate::builders::vmware_engine::UpdateCluster::new(self.inner.clone())
            .set_cluster(cluster.into())
    }

    /// 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
    pub fn delete_cluster(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::DeleteCluster {
        crate::builders::vmware_engine::DeleteCluster::new(self.inner.clone()).set_name(name.into())
    }

    /// Lists nodes in a given cluster.
    pub fn list_nodes(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListNodes {
        crate::builders::vmware_engine::ListNodes::new(self.inner.clone()).set_parent(parent.into())
    }

    /// Gets details of a single node.
    pub fn get_node(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetNode {
        crate::builders::vmware_engine::GetNode::new(self.inner.clone()).set_name(name.into())
    }

    /// Lists external IP addresses assigned to VMware workload VMs in a given
    /// private cloud.
    pub fn list_external_addresses(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListExternalAddresses {
        crate::builders::vmware_engine::ListExternalAddresses::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// Lists external IP addresses assigned to VMware workload VMs within the
    /// scope of the given network policy.
    pub fn fetch_network_policy_external_addresses(
        &self,
        network_policy: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::FetchNetworkPolicyExternalAddresses {
        crate::builders::vmware_engine::FetchNetworkPolicyExternalAddresses::new(self.inner.clone())
            .set_network_policy(network_policy.into())
    }

    /// Gets details of a single external IP address.
    pub fn get_external_address(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetExternalAddress {
        crate::builders::vmware_engine::GetExternalAddress::new(self.inner.clone())
            .set_name(name.into())
    }

    /// 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
    pub fn create_external_address(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::CreateExternalAddress {
        crate::builders::vmware_engine::CreateExternalAddress::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn update_external_address(
        &self,
        external_address: impl Into<crate::model::ExternalAddress>,
    ) -> crate::builders::vmware_engine::UpdateExternalAddress {
        crate::builders::vmware_engine::UpdateExternalAddress::new(self.inner.clone())
            .set_external_address(external_address.into())
    }

    /// 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
    pub fn delete_external_address(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::DeleteExternalAddress {
        crate::builders::vmware_engine::DeleteExternalAddress::new(self.inner.clone())
            .set_name(name.into())
    }

    /// Lists subnets in a given private cloud.
    pub fn list_subnets(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListSubnets {
        crate::builders::vmware_engine::ListSubnets::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// Gets details of a single subnet.
    pub fn get_subnet(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetSubnet {
        crate::builders::vmware_engine::GetSubnet::new(self.inner.clone()).set_name(name.into())
    }

    /// 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
    pub fn update_subnet(
        &self,
        subnet: impl Into<crate::model::Subnet>,
    ) -> crate::builders::vmware_engine::UpdateSubnet {
        crate::builders::vmware_engine::UpdateSubnet::new(self.inner.clone())
            .set_subnet(subnet.into())
    }

    /// Lists `ExternalAccessRule` resources in the specified network policy.
    pub fn list_external_access_rules(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListExternalAccessRules {
        crate::builders::vmware_engine::ListExternalAccessRules::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// Gets details of a single external access rule.
    pub fn get_external_access_rule(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetExternalAccessRule {
        crate::builders::vmware_engine::GetExternalAccessRule::new(self.inner.clone())
            .set_name(name.into())
    }

    /// 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
    pub fn create_external_access_rule(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::CreateExternalAccessRule {
        crate::builders::vmware_engine::CreateExternalAccessRule::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn update_external_access_rule(
        &self,
        external_access_rule: impl Into<crate::model::ExternalAccessRule>,
    ) -> crate::builders::vmware_engine::UpdateExternalAccessRule {
        crate::builders::vmware_engine::UpdateExternalAccessRule::new(self.inner.clone())
            .set_external_access_rule(external_access_rule.into())
    }

    /// 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
    pub fn delete_external_access_rule(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::DeleteExternalAccessRule {
        crate::builders::vmware_engine::DeleteExternalAccessRule::new(self.inner.clone())
            .set_name(name.into())
    }

    /// Lists logging servers configured for a given private
    /// cloud.
    pub fn list_logging_servers(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListLoggingServers {
        crate::builders::vmware_engine::ListLoggingServers::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// Gets details of a logging server.
    pub fn get_logging_server(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetLoggingServer {
        crate::builders::vmware_engine::GetLoggingServer::new(self.inner.clone())
            .set_name(name.into())
    }

    /// 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
    pub fn create_logging_server(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::CreateLoggingServer {
        crate::builders::vmware_engine::CreateLoggingServer::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn update_logging_server(
        &self,
        logging_server: impl Into<crate::model::LoggingServer>,
    ) -> crate::builders::vmware_engine::UpdateLoggingServer {
        crate::builders::vmware_engine::UpdateLoggingServer::new(self.inner.clone())
            .set_logging_server(logging_server.into())
    }

    /// 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
    pub fn delete_logging_server(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::DeleteLoggingServer {
        crate::builders::vmware_engine::DeleteLoggingServer::new(self.inner.clone())
            .set_name(name.into())
    }

    /// Lists node types
    pub fn list_node_types(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListNodeTypes {
        crate::builders::vmware_engine::ListNodeTypes::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// Gets details of a single `NodeType`.
    pub fn get_node_type(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetNodeType {
        crate::builders::vmware_engine::GetNodeType::new(self.inner.clone()).set_name(name.into())
    }

    /// Gets details of credentials for NSX appliance.
    pub fn show_nsx_credentials(
        &self,
        private_cloud: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ShowNsxCredentials {
        crate::builders::vmware_engine::ShowNsxCredentials::new(self.inner.clone())
            .set_private_cloud(private_cloud.into())
    }

    /// Gets details of credentials for Vcenter appliance.
    pub fn show_vcenter_credentials(
        &self,
        private_cloud: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ShowVcenterCredentials {
        crate::builders::vmware_engine::ShowVcenterCredentials::new(self.inner.clone())
            .set_private_cloud(private_cloud.into())
    }

    /// 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
    pub fn reset_nsx_credentials(
        &self,
        private_cloud: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ResetNsxCredentials {
        crate::builders::vmware_engine::ResetNsxCredentials::new(self.inner.clone())
            .set_private_cloud(private_cloud.into())
    }

    /// 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
    pub fn reset_vcenter_credentials(
        &self,
        private_cloud: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ResetVcenterCredentials {
        crate::builders::vmware_engine::ResetVcenterCredentials::new(self.inner.clone())
            .set_private_cloud(private_cloud.into())
    }

    /// Gets details of the `DnsForwarding` config.
    pub fn get_dns_forwarding(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetDnsForwarding {
        crate::builders::vmware_engine::GetDnsForwarding::new(self.inner.clone())
            .set_name(name.into())
    }

    /// 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
    pub fn update_dns_forwarding(
        &self,
        dns_forwarding: impl Into<crate::model::DnsForwarding>,
    ) -> crate::builders::vmware_engine::UpdateDnsForwarding {
        crate::builders::vmware_engine::UpdateDnsForwarding::new(self.inner.clone())
            .set_dns_forwarding(dns_forwarding.into())
    }

    /// 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.
    pub fn get_network_peering(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetNetworkPeering {
        crate::builders::vmware_engine::GetNetworkPeering::new(self.inner.clone())
            .set_name(name.into())
    }

    /// Lists `NetworkPeering` resources in a given project. NetworkPeering is a
    /// global resource and location can only be global.
    pub fn list_network_peerings(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListNetworkPeerings {
        crate::builders::vmware_engine::ListNetworkPeerings::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn create_network_peering(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::CreateNetworkPeering {
        crate::builders::vmware_engine::CreateNetworkPeering::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn delete_network_peering(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::DeleteNetworkPeering {
        crate::builders::vmware_engine::DeleteNetworkPeering::new(self.inner.clone())
            .set_name(name.into())
    }

    /// 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
    pub fn update_network_peering(
        &self,
        network_peering: impl Into<crate::model::NetworkPeering>,
    ) -> crate::builders::vmware_engine::UpdateNetworkPeering {
        crate::builders::vmware_engine::UpdateNetworkPeering::new(self.inner.clone())
            .set_network_peering(network_peering.into())
    }

    /// Lists the network peering routes exchanged over a peering connection.
    /// NetworkPeering is a global resource and location can only be global.
    pub fn list_peering_routes(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListPeeringRoutes {
        crate::builders::vmware_engine::ListPeeringRoutes::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn create_hcx_activation_key(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::CreateHcxActivationKey {
        crate::builders::vmware_engine::CreateHcxActivationKey::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// Lists `HcxActivationKey` resources in a given private cloud.
    pub fn list_hcx_activation_keys(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListHcxActivationKeys {
        crate::builders::vmware_engine::ListHcxActivationKeys::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// Retrieves a `HcxActivationKey` resource by its resource name.
    pub fn get_hcx_activation_key(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetHcxActivationKey {
        crate::builders::vmware_engine::GetHcxActivationKey::new(self.inner.clone())
            .set_name(name.into())
    }

    /// Retrieves a `NetworkPolicy` resource by its resource name.
    pub fn get_network_policy(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetNetworkPolicy {
        crate::builders::vmware_engine::GetNetworkPolicy::new(self.inner.clone())
            .set_name(name.into())
    }

    /// Lists `NetworkPolicy` resources in a specified project and location.
    pub fn list_network_policies(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListNetworkPolicies {
        crate::builders::vmware_engine::ListNetworkPolicies::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn create_network_policy(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::CreateNetworkPolicy {
        crate::builders::vmware_engine::CreateNetworkPolicy::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn update_network_policy(
        &self,
        network_policy: impl Into<crate::model::NetworkPolicy>,
    ) -> crate::builders::vmware_engine::UpdateNetworkPolicy {
        crate::builders::vmware_engine::UpdateNetworkPolicy::new(self.inner.clone())
            .set_network_policy(network_policy.into())
    }

    /// 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
    pub fn delete_network_policy(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::DeleteNetworkPolicy {
        crate::builders::vmware_engine::DeleteNetworkPolicy::new(self.inner.clone())
            .set_name(name.into())
    }

    /// Lists Consumer VPCs bound to Management DNS Zone of a given private cloud.
    pub fn list_management_dns_zone_bindings(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListManagementDnsZoneBindings {
        crate::builders::vmware_engine::ListManagementDnsZoneBindings::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// Retrieves a 'ManagementDnsZoneBinding' resource by its resource name.
    pub fn get_management_dns_zone_binding(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetManagementDnsZoneBinding {
        crate::builders::vmware_engine::GetManagementDnsZoneBinding::new(self.inner.clone())
            .set_name(name.into())
    }

    /// 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
    pub fn create_management_dns_zone_binding(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::CreateManagementDnsZoneBinding {
        crate::builders::vmware_engine::CreateManagementDnsZoneBinding::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn update_management_dns_zone_binding(
        &self,
        management_dns_zone_binding: impl Into<crate::model::ManagementDnsZoneBinding>,
    ) -> crate::builders::vmware_engine::UpdateManagementDnsZoneBinding {
        crate::builders::vmware_engine::UpdateManagementDnsZoneBinding::new(self.inner.clone())
            .set_management_dns_zone_binding(management_dns_zone_binding.into())
    }

    /// 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
    pub fn delete_management_dns_zone_binding(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::DeleteManagementDnsZoneBinding {
        crate::builders::vmware_engine::DeleteManagementDnsZoneBinding::new(self.inner.clone())
            .set_name(name.into())
    }

    /// 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
    pub fn repair_management_dns_zone_binding(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::RepairManagementDnsZoneBinding {
        crate::builders::vmware_engine::RepairManagementDnsZoneBinding::new(self.inner.clone())
            .set_name(name.into())
    }

    /// 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
    pub fn create_vmware_engine_network(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::CreateVmwareEngineNetwork {
        crate::builders::vmware_engine::CreateVmwareEngineNetwork::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn update_vmware_engine_network(
        &self,
        vmware_engine_network: impl Into<crate::model::VmwareEngineNetwork>,
    ) -> crate::builders::vmware_engine::UpdateVmwareEngineNetwork {
        crate::builders::vmware_engine::UpdateVmwareEngineNetwork::new(self.inner.clone())
            .set_vmware_engine_network(vmware_engine_network.into())
    }

    /// 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
    pub fn delete_vmware_engine_network(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::DeleteVmwareEngineNetwork {
        crate::builders::vmware_engine::DeleteVmwareEngineNetwork::new(self.inner.clone())
            .set_name(name.into())
    }

    /// 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`).
    pub fn get_vmware_engine_network(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetVmwareEngineNetwork {
        crate::builders::vmware_engine::GetVmwareEngineNetwork::new(self.inner.clone())
            .set_name(name.into())
    }

    /// Lists `VmwareEngineNetwork` resources in a given project and location.
    pub fn list_vmware_engine_networks(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListVmwareEngineNetworks {
        crate::builders::vmware_engine::ListVmwareEngineNetworks::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn create_private_connection(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::CreatePrivateConnection {
        crate::builders::vmware_engine::CreatePrivateConnection::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// Retrieves a `PrivateConnection` resource by its resource name. The resource
    /// contains details of the private connection, such as connected
    /// network, routing mode and state.
    pub fn get_private_connection(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetPrivateConnection {
        crate::builders::vmware_engine::GetPrivateConnection::new(self.inner.clone())
            .set_name(name.into())
    }

    /// Lists `PrivateConnection` resources in a given project and location.
    pub fn list_private_connections(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListPrivateConnections {
        crate::builders::vmware_engine::ListPrivateConnections::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn update_private_connection(
        &self,
        private_connection: impl Into<crate::model::PrivateConnection>,
    ) -> crate::builders::vmware_engine::UpdatePrivateConnection {
        crate::builders::vmware_engine::UpdatePrivateConnection::new(self.inner.clone())
            .set_private_connection(private_connection.into())
    }

    /// 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
    pub fn delete_private_connection(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::DeletePrivateConnection {
        crate::builders::vmware_engine::DeletePrivateConnection::new(self.inner.clone())
            .set_name(name.into())
    }

    /// Lists the private connection routes exchanged over a peering connection.
    pub fn list_private_connection_peering_routes(
        &self,
        parent: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListPrivateConnectionPeeringRoutes {
        crate::builders::vmware_engine::ListPrivateConnectionPeeringRoutes::new(self.inner.clone())
            .set_parent(parent.into())
    }

    /// 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
    pub fn grant_dns_bind_permission(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GrantDnsBindPermission {
        crate::builders::vmware_engine::GrantDnsBindPermission::new(self.inner.clone())
            .set_name(name.into())
    }

    /// 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.
    pub fn get_dns_bind_permission(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetDnsBindPermission {
        crate::builders::vmware_engine::GetDnsBindPermission::new(self.inner.clone())
            .set_name(name.into())
    }

    /// 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
    pub fn revoke_dns_bind_permission(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::RevokeDnsBindPermission {
        crate::builders::vmware_engine::RevokeDnsBindPermission::new(self.inner.clone())
            .set_name(name.into())
    }

    /// Lists information about the supported locations for this service.
    pub fn list_locations(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListLocations {
        crate::builders::vmware_engine::ListLocations::new(self.inner.clone()).set_name(name.into())
    }

    /// Gets information about a location.
    pub fn get_location(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetLocation {
        crate::builders::vmware_engine::GetLocation::new(self.inner.clone()).set_name(name.into())
    }

    /// Sets the access control policy on the specified resource. Replaces
    /// any existing policy.
    ///
    /// Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED`
    /// errors.
    pub fn set_iam_policy(
        &self,
        resource: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::SetIamPolicy {
        crate::builders::vmware_engine::SetIamPolicy::new(self.inner.clone())
            .set_resource(resource.into())
    }

    /// Gets the access control policy for a resource. Returns an empty policy
    /// if the resource exists and does not have a policy set.
    pub fn get_iam_policy(
        &self,
        resource: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetIamPolicy {
        crate::builders::vmware_engine::GetIamPolicy::new(self.inner.clone())
            .set_resource(resource.into())
    }

    /// 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.
    pub fn test_iam_permissions(
        &self,
        resource: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::TestIamPermissions {
        crate::builders::vmware_engine::TestIamPermissions::new(self.inner.clone())
            .set_resource(resource.into())
    }

    /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
    ///
    /// [google.longrunning.Operations]: longrunning::client::Operations
    pub fn list_operations(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::ListOperations {
        crate::builders::vmware_engine::ListOperations::new(self.inner.clone())
            .set_name(name.into())
    }

    /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
    ///
    /// [google.longrunning.Operations]: longrunning::client::Operations
    pub fn get_operation(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::GetOperation {
        crate::builders::vmware_engine::GetOperation::new(self.inner.clone()).set_name(name.into())
    }

    /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
    ///
    /// [google.longrunning.Operations]: longrunning::client::Operations
    pub fn delete_operation(
        &self,
        name: impl Into<std::string::String>,
    ) -> crate::builders::vmware_engine::DeleteOperation {
        crate::builders::vmware_engine::DeleteOperation::new(self.inner.clone())
            .set_name(name.into())
    }
}