google-cloud-vmmigration-v1 1.9.0

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

/// Implements a [VmMigration](super::stub::VmMigration) decorator for logging and tracing.
#[derive(Clone, Debug)]
pub struct VmMigration<T>
where
    T: super::stub::VmMigration + std::fmt::Debug + Send + Sync,
{
    inner: T,
    duration: gaxi::observability::DurationMetric,
}

impl<T> VmMigration<T>
where
    T: super::stub::VmMigration + std::fmt::Debug + Send + Sync,
{
    pub fn new(inner: T) -> Self {
        Self {
            inner,
            duration: gaxi::observability::DurationMetric::new(&info::INSTRUMENTATION_CLIENT_INFO),
        }
    }
}

impl<T> super::stub::VmMigration for VmMigration<T>
where
    T: super::stub::VmMigration + std::fmt::Debug + Send + Sync,
{
    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_sources(
        &self,
        req: crate::model::ListSourcesRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListSourcesResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_sources",
            self.inner.list_sources(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_source(
        &self,
        req: crate::model::GetSourceRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Source>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_source",
            self.inner.get_source(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_source(
        &self,
        req: crate::model::CreateSourceRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::create_source",
            self.inner.create_source(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn update_source(
        &self,
        req: crate::model::UpdateSourceRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::update_source",
            self.inner.update_source(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_source(
        &self,
        req: crate::model::DeleteSourceRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::delete_source",
            self.inner.delete_source(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn fetch_inventory(
        &self,
        req: crate::model::FetchInventoryRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::FetchInventoryResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::fetch_inventory",
            self.inner.fetch_inventory(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn fetch_storage_inventory(
        &self,
        req: crate::model::FetchStorageInventoryRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::FetchStorageInventoryResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::fetch_storage_inventory",
            self.inner.fetch_storage_inventory(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_utilization_reports(
        &self,
        req: crate::model::ListUtilizationReportsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListUtilizationReportsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_utilization_reports",
            self.inner.list_utilization_reports(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_utilization_report(
        &self,
        req: crate::model::GetUtilizationReportRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::UtilizationReport>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_utilization_report",
            self.inner.get_utilization_report(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_utilization_report(
        &self,
        req: crate::model::CreateUtilizationReportRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::create_utilization_report",
            self.inner.create_utilization_report(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_utilization_report(
        &self,
        req: crate::model::DeleteUtilizationReportRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::delete_utilization_report",
            self.inner.delete_utilization_report(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_datacenter_connectors(
        &self,
        req: crate::model::ListDatacenterConnectorsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListDatacenterConnectorsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_datacenter_connectors",
            self.inner.list_datacenter_connectors(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_datacenter_connector(
        &self,
        req: crate::model::GetDatacenterConnectorRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::DatacenterConnector>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_datacenter_connector",
            self.inner.get_datacenter_connector(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_datacenter_connector(
        &self,
        req: crate::model::CreateDatacenterConnectorRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::create_datacenter_connector",
            self.inner.create_datacenter_connector(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_datacenter_connector(
        &self,
        req: crate::model::DeleteDatacenterConnectorRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::delete_datacenter_connector",
            self.inner.delete_datacenter_connector(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn upgrade_appliance(
        &self,
        req: crate::model::UpgradeApplianceRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::upgrade_appliance",
            self.inner.upgrade_appliance(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_migrating_vm(
        &self,
        req: crate::model::CreateMigratingVmRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::create_migrating_vm",
            self.inner.create_migrating_vm(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_migrating_vms(
        &self,
        req: crate::model::ListMigratingVmsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListMigratingVmsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_migrating_vms",
            self.inner.list_migrating_vms(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_migrating_vm(
        &self,
        req: crate::model::GetMigratingVmRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::MigratingVm>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_migrating_vm",
            self.inner.get_migrating_vm(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn update_migrating_vm(
        &self,
        req: crate::model::UpdateMigratingVmRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::update_migrating_vm",
            self.inner.update_migrating_vm(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_migrating_vm(
        &self,
        req: crate::model::DeleteMigratingVmRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::delete_migrating_vm",
            self.inner.delete_migrating_vm(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn start_migration(
        &self,
        req: crate::model::StartMigrationRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::start_migration",
            self.inner.start_migration(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn resume_migration(
        &self,
        req: crate::model::ResumeMigrationRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::resume_migration",
            self.inner.resume_migration(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn pause_migration(
        &self,
        req: crate::model::PauseMigrationRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::pause_migration",
            self.inner.pause_migration(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn finalize_migration(
        &self,
        req: crate::model::FinalizeMigrationRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::finalize_migration",
            self.inner.finalize_migration(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn extend_migration(
        &self,
        req: crate::model::ExtendMigrationRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::extend_migration",
            self.inner.extend_migration(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_clone_job(
        &self,
        req: crate::model::CreateCloneJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::create_clone_job",
            self.inner.create_clone_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn cancel_clone_job(
        &self,
        req: crate::model::CancelCloneJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::cancel_clone_job",
            self.inner.cancel_clone_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_clone_jobs(
        &self,
        req: crate::model::ListCloneJobsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListCloneJobsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_clone_jobs",
            self.inner.list_clone_jobs(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_clone_job(
        &self,
        req: crate::model::GetCloneJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::CloneJob>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_clone_job",
            self.inner.get_clone_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_cutover_job(
        &self,
        req: crate::model::CreateCutoverJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::create_cutover_job",
            self.inner.create_cutover_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn cancel_cutover_job(
        &self,
        req: crate::model::CancelCutoverJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::cancel_cutover_job",
            self.inner.cancel_cutover_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_cutover_jobs(
        &self,
        req: crate::model::ListCutoverJobsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListCutoverJobsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_cutover_jobs",
            self.inner.list_cutover_jobs(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_cutover_job(
        &self,
        req: crate::model::GetCutoverJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::CutoverJob>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_cutover_job",
            self.inner.get_cutover_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_groups(
        &self,
        req: crate::model::ListGroupsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListGroupsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_groups",
            self.inner.list_groups(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_group(
        &self,
        req: crate::model::GetGroupRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Group>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_group",
            self.inner.get_group(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_group(
        &self,
        req: crate::model::CreateGroupRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::create_group",
            self.inner.create_group(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn update_group(
        &self,
        req: crate::model::UpdateGroupRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::update_group",
            self.inner.update_group(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_group(
        &self,
        req: crate::model::DeleteGroupRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::delete_group",
            self.inner.delete_group(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn add_group_migration(
        &self,
        req: crate::model::AddGroupMigrationRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::add_group_migration",
            self.inner.add_group_migration(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn remove_group_migration(
        &self,
        req: crate::model::RemoveGroupMigrationRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::remove_group_migration",
            self.inner.remove_group_migration(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_target_projects(
        &self,
        req: crate::model::ListTargetProjectsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListTargetProjectsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_target_projects",
            self.inner.list_target_projects(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_target_project(
        &self,
        req: crate::model::GetTargetProjectRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::TargetProject>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_target_project",
            self.inner.get_target_project(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_target_project(
        &self,
        req: crate::model::CreateTargetProjectRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::create_target_project",
            self.inner.create_target_project(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn update_target_project(
        &self,
        req: crate::model::UpdateTargetProjectRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::update_target_project",
            self.inner.update_target_project(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_target_project(
        &self,
        req: crate::model::DeleteTargetProjectRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::delete_target_project",
            self.inner.delete_target_project(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_replication_cycles(
        &self,
        req: crate::model::ListReplicationCyclesRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListReplicationCyclesResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_replication_cycles",
            self.inner.list_replication_cycles(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_replication_cycle(
        &self,
        req: crate::model::GetReplicationCycleRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ReplicationCycle>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_replication_cycle",
            self.inner.get_replication_cycle(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_image_imports(
        &self,
        req: crate::model::ListImageImportsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListImageImportsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_image_imports",
            self.inner.list_image_imports(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_image_import(
        &self,
        req: crate::model::GetImageImportRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ImageImport>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_image_import",
            self.inner.get_image_import(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_image_import(
        &self,
        req: crate::model::CreateImageImportRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::create_image_import",
            self.inner.create_image_import(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_image_import(
        &self,
        req: crate::model::DeleteImageImportRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::delete_image_import",
            self.inner.delete_image_import(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_image_import_jobs(
        &self,
        req: crate::model::ListImageImportJobsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListImageImportJobsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_image_import_jobs",
            self.inner.list_image_import_jobs(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_image_import_job(
        &self,
        req: crate::model::GetImageImportJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ImageImportJob>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_image_import_job",
            self.inner.get_image_import_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn cancel_image_import_job(
        &self,
        req: crate::model::CancelImageImportJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::cancel_image_import_job",
            self.inner.cancel_image_import_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_disk_migration_job(
        &self,
        req: crate::model::CreateDiskMigrationJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::create_disk_migration_job",
            self.inner.create_disk_migration_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_disk_migration_jobs(
        &self,
        req: crate::model::ListDiskMigrationJobsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListDiskMigrationJobsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_disk_migration_jobs",
            self.inner.list_disk_migration_jobs(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_disk_migration_job(
        &self,
        req: crate::model::GetDiskMigrationJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::DiskMigrationJob>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_disk_migration_job",
            self.inner.get_disk_migration_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn update_disk_migration_job(
        &self,
        req: crate::model::UpdateDiskMigrationJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::update_disk_migration_job",
            self.inner.update_disk_migration_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_disk_migration_job(
        &self,
        req: crate::model::DeleteDiskMigrationJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::delete_disk_migration_job",
            self.inner.delete_disk_migration_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn run_disk_migration_job(
        &self,
        req: crate::model::RunDiskMigrationJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::run_disk_migration_job",
            self.inner.run_disk_migration_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn cancel_disk_migration_job(
        &self,
        req: crate::model::CancelDiskMigrationJobRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::cancel_disk_migration_job",
            self.inner.cancel_disk_migration_job(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_locations(
        &self,
        req: google_cloud_location::model::ListLocationsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_location::model::ListLocationsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_locations",
            self.inner.list_locations(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_location(
        &self,
        req: google_cloud_location::model::GetLocationRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_location::model::Location>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_location",
            self.inner.get_location(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_operations(
        &self,
        req: google_cloud_longrunning::model::ListOperationsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::ListOperationsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::list_operations",
            self.inner.list_operations(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_operation(
        &self,
        req: google_cloud_longrunning::model::GetOperationRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_longrunning::model::Operation>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::get_operation",
            self.inner.get_operation(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_operation(
        &self,
        req: google_cloud_longrunning::model::DeleteOperationRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<()>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::delete_operation",
            self.inner.delete_operation(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn cancel_operation(
        &self,
        req: google_cloud_longrunning::model::CancelOperationRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<()>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::VmMigration::cancel_operation",
            self.inner.cancel_operation(req, options));
        pending.await
    }

    fn get_polling_error_policy(
        &self,
        options: &crate::RequestOptions,
    ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
        self.inner.get_polling_error_policy(options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &crate::RequestOptions,
    ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
        self.inner.get_polling_backoff_policy(options)
    }
}

pub(crate) mod info {
    const NAME: &str = env!("CARGO_PKG_NAME");
    const VERSION: &str = env!("CARGO_PKG_VERSION");
    pub(crate) static INSTRUMENTATION_CLIENT_INFO: std::sync::LazyLock<
        gaxi::options::InstrumentationClientInfo,
    > = std::sync::LazyLock::new(|| {
        let mut info = gaxi::options::InstrumentationClientInfo::default();
        info.service_name = "vmmigration";
        info.client_version = VERSION;
        info.client_artifact = NAME;
        info.default_host = "vmmigration";
        info
    });
}