google-cloud-kms-v1 1.8.0

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

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

impl<T> Autokey<T>
where
    T: super::stub::Autokey + 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::Autokey for Autokey<T>
where
    T: super::stub::Autokey + std::fmt::Debug + Send + Sync,
{
    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_key_handle(
        &self,
        req: crate::model::CreateKeyHandleRequest,
        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::Autokey::create_key_handle",
            self.inner.create_key_handle(req, options));
        pending.await
    }

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

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_key_handles(
        &self,
        req: crate::model::ListKeyHandlesRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListKeyHandlesResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::Autokey::list_key_handles",
            self.inner.list_key_handles(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::Autokey::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::Autokey::get_location",
            self.inner.get_location(req, options));
        pending.await
    }

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

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

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn test_iam_permissions(
        &self,
        req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::Autokey::test_iam_permissions",
            self.inner.test_iam_permissions(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::Autokey::get_operation",
            self.inner.get_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)
    }
}

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

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

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

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn show_effective_autokey_config(
        &self,
        req: crate::model::ShowEffectiveAutokeyConfigRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ShowEffectiveAutokeyConfigResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::AutokeyAdmin::show_effective_autokey_config",
            self.inner.show_effective_autokey_config(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::AutokeyAdmin::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::AutokeyAdmin::get_location",
            self.inner.get_location(req, options));
        pending.await
    }

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

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

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn test_iam_permissions(
        &self,
        req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::AutokeyAdmin::test_iam_permissions",
            self.inner.test_iam_permissions(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::AutokeyAdmin::get_operation",
            self.inner.get_operation(req, options));
        pending.await
    }
}

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

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

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

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

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

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

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

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn verify_connectivity(
        &self,
        req: crate::model::VerifyConnectivityRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::VerifyConnectivityResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::EkmService::verify_connectivity",
            self.inner.verify_connectivity(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::EkmService::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::EkmService::get_location",
            self.inner.get_location(req, options));
        pending.await
    }

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

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

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn test_iam_permissions(
        &self,
        req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::EkmService::test_iam_permissions",
            self.inner.test_iam_permissions(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::EkmService::get_operation",
            self.inner.get_operation(req, options));
        pending.await
    }
}

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

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

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

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_single_tenant_hsm_instance(
        &self,
        req: crate::model::CreateSingleTenantHsmInstanceRequest,
        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::HsmManagement::create_single_tenant_hsm_instance",
            self.inner.create_single_tenant_hsm_instance(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_single_tenant_hsm_instance_proposal(
        &self,
        req: crate::model::CreateSingleTenantHsmInstanceProposalRequest,
        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::HsmManagement::create_single_tenant_hsm_instance_proposal",
            self.inner.create_single_tenant_hsm_instance_proposal(req, options));
        pending.await
    }

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

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn execute_single_tenant_hsm_instance_proposal(
        &self,
        req: crate::model::ExecuteSingleTenantHsmInstanceProposalRequest,
        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::HsmManagement::execute_single_tenant_hsm_instance_proposal",
            self.inner.execute_single_tenant_hsm_instance_proposal(req, options));
        pending.await
    }

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

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

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

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

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

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn test_iam_permissions(
        &self,
        req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::HsmManagement::test_iam_permissions",
            self.inner.test_iam_permissions(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::HsmManagement::get_operation",
            self.inner.get_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)
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_crypto_key(
        &self,
        req: crate::model::DeleteCryptoKeyRequest,
        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::KeyManagementService::delete_crypto_key",
            self.inner.delete_crypto_key(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_crypto_key_version(
        &self,
        req: crate::model::DeleteCryptoKeyVersionRequest,
        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::KeyManagementService::delete_crypto_key_version",
            self.inner.delete_crypto_key_version(req, options));
        pending.await
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn generate_random_bytes(
        &self,
        req: crate::model::GenerateRandomBytesRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::GenerateRandomBytesResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::KeyManagementService::generate_random_bytes",
            self.inner.generate_random_bytes(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::KeyManagementService::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::KeyManagementService::get_location",
            self.inner.get_location(req, options));
        pending.await
    }

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

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

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn test_iam_permissions(
        &self,
        req: google_cloud_iam_v1::model::TestIamPermissionsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_iam_v1::model::TestIamPermissionsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::KeyManagementService::test_iam_permissions",
            self.inner.test_iam_permissions(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::KeyManagementService::get_operation",
            self.inner.get_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 = "cloudkms";
        info.client_version = VERSION;
        info.client_artifact = NAME;
        info.default_host = "cloudkms";
        info
    });
}