google-cloud-dataform-v1 1.9.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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