google-cloud-bigquery-v2 0.1.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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