google-cloud-sql-v1 2.5.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 [SqlBackupRunsService](super::stub::SqlBackupRunsService) decorator for logging and tracing.
#[derive(Clone, Debug)]
pub struct SqlBackupRunsService<T>
where
    T: super::stub::SqlBackupRunsService + std::fmt::Debug + Send + Sync,
{
    inner: T,
    duration: gaxi::observability::DurationMetric,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 = "sqladmin";
        info.client_version = VERSION;
        info.client_artifact = NAME;
        info.default_host = "sqladmin";
        info
    });
}