google-cloud-storage 1.11.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.

#[allow(unused_imports)]
use crate::Error;
use crate::Result;

const DEFAULT_HOST: &str = "https://storage.googleapis.com";

mod info {
    const NAME: &str = env!("CARGO_PKG_NAME");
    const VERSION: &str = env!("CARGO_PKG_VERSION");
    pub(crate) static X_GOOG_API_CLIENT_HEADER: std::sync::LazyLock<String> =
        std::sync::LazyLock::new(|| {
            let ac = gaxi::api_header::XGoogApiClient {
                name: NAME,
                version: VERSION,
                library_type: gaxi::api_header::GAPIC,
            };
            ac.grpc_header_value()
        });
}

/// Implements [StorageControl](super::stub::StorageControl) using a Tonic-generated client.
#[derive(Clone)]
pub struct StorageControl {
    inner: gaxi::grpc::Client,
}

impl std::fmt::Debug for StorageControl {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        f.debug_struct("StorageControl")
            .field("inner", &self.inner)
            .finish()
    }
}

impl StorageControl {
    pub async fn new(config: gaxi::options::ClientConfig) -> crate::ClientBuilderResult<Self> {
        let inner = if gaxi::options::tracing_enabled(&config) {
            gaxi::grpc::Client::new_with_instrumentation(
                config,
                DEFAULT_HOST,
                &super::tracing::info::INSTRUMENTATION_CLIENT_INFO,
            )
            .await?
        } else {
            gaxi::grpc::Client::new(config, DEFAULT_HOST).await?
        };
        Ok(Self { inner })
    }
}

impl super::stub::StorageControl for StorageControl {
    async fn delete_bucket(
        &self,
        req: crate::model::DeleteBucketRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<()>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.storage.v2.Storage", "DeleteBucket"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.storage.v2.Storage/DeleteBucket");
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[None
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req).map(|m| &m.name).map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("bucket", v))])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req).map(|m| &m.name).map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "name",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = ();
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/DeleteBucket");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, ()>)
    }

    async fn get_bucket(
        &self,
        req: crate::model::GetBucketRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Bucket>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.storage.v2.Storage", "GetBucket"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.storage.v2.Storage/GetBucket");
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[None
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req).map(|m| &m.name).map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("bucket", v))])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req).map(|m| &m.name).map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "name",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = crate::google::storage::v2::Bucket;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/GetBucket");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::Bucket>)
    }

    async fn create_bucket(
        &self,
        req: crate::model::CreateBucketRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Bucket>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.storage.v2.Storage", "CreateBucket"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.storage.v2.Storage/CreateBucket");
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[None
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req)
                            .and_then(|m| m.bucket.as_ref())
                            .map(|m| &m.project)
                            .map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req).map(|m| &m.parent).map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("project", v))])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req)
                        .and_then(|m| m.bucket.as_ref())
                        .map(|m| &m.project)
                        .map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "bucket.project",
                    "**",
                );
                paths.push(builder.build());
            }
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req).map(|m| &m.parent).map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "parent",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = crate::google::storage::v2::Bucket;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/CreateBucket");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::Bucket>)
    }

    async fn list_buckets(
        &self,
        req: crate::model::ListBucketsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListBucketsResponse>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.storage.v2.Storage", "ListBuckets"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.storage.v2.Storage/ListBuckets");
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[None
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req).map(|m| &m.parent).map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("project", v))])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req).map(|m| &m.parent).map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "parent",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = crate::google::storage::v2::ListBucketsResponse;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/ListBuckets");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::ListBucketsResponse>)
    }

    async fn lock_bucket_retention_policy(
        &self,
        req: crate::model::LockBucketRetentionPolicyRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Bucket>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new(
                "google.storage.v2.Storage",
                "LockBucketRetentionPolicy",
            ));
            e
        };
        let path = http::uri::PathAndQuery::from_static(
            "/google.storage.v2.Storage/LockBucketRetentionPolicy",
        );
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[None
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req).map(|m| &m.bucket).map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("bucket", v))])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req).map(|m| &m.bucket).map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "bucket",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = crate::google::storage::v2::Bucket;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/LockBucketRetentionPolicy");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::Bucket>)
    }

    async fn update_bucket(
        &self,
        req: crate::model::UpdateBucketRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Bucket>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.storage.v2.Storage", "UpdateBucket"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.storage.v2.Storage/UpdateBucket");
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[None
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req)
                            .and_then(|m| m.bucket.as_ref())
                            .map(|m| &m.name)
                            .map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("bucket", v))])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req)
                        .and_then(|m| m.bucket.as_ref())
                        .map(|m| &m.name)
                        .map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "bucket.name",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = crate::google::storage::v2::Bucket;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/UpdateBucket");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::Bucket>)
    }

    async fn compose_object(
        &self,
        req: crate::model::ComposeObjectRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Object>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new(
                "google.storage.v2.Storage",
                "ComposeObject",
            ));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.storage.v2.Storage/ComposeObject");
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[None
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req)
                            .and_then(|m| m.destination.as_ref())
                            .map(|m| &m.bucket)
                            .map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("bucket", v))])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req)
                        .and_then(|m| m.destination.as_ref())
                        .map(|m| &m.bucket)
                        .map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "destination.bucket",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = crate::google::storage::v2::Object;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/ComposeObject");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::Object>)
    }

    async fn delete_object(
        &self,
        req: crate::model::DeleteObjectRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<()>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.storage.v2.Storage", "DeleteObject"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.storage.v2.Storage/DeleteObject");
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[None
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req).map(|m| &m.bucket).map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("bucket", v))])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req).map(|m| &m.bucket).map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "bucket",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = ();
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/DeleteObject");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, ()>)
    }

    async fn restore_object(
        &self,
        req: crate::model::RestoreObjectRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Object>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new(
                "google.storage.v2.Storage",
                "RestoreObject",
            ));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.storage.v2.Storage/RestoreObject");
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[None
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req).map(|m| &m.bucket).map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("bucket", v))])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req).map(|m| &m.bucket).map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "bucket",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = crate::google::storage::v2::Object;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/RestoreObject");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::Object>)
    }

    async fn get_object(
        &self,
        req: crate::model::GetObjectRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Object>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.storage.v2.Storage", "GetObject"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.storage.v2.Storage/GetObject");
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[None
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req).map(|m| &m.bucket).map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("bucket", v))])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req).map(|m| &m.bucket).map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "bucket",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = crate::google::storage::v2::Object;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/GetObject");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::Object>)
    }

    async fn update_object(
        &self,
        req: crate::model::UpdateObjectRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Object>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.storage.v2.Storage", "UpdateObject"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.storage.v2.Storage/UpdateObject");
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[None
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req)
                            .and_then(|m| m.object.as_ref())
                            .map(|m| &m.bucket)
                            .map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("bucket", v))])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req)
                        .and_then(|m| m.object.as_ref())
                        .map(|m| &m.bucket)
                        .map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "object.bucket",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = crate::google::storage::v2::Object;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/UpdateObject");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::Object>)
    }

    async fn list_objects(
        &self,
        req: crate::model::ListObjectsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListObjectsResponse>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.storage.v2.Storage", "ListObjects"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.storage.v2.Storage/ListObjects");
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[None
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req).map(|m| &m.parent).map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("bucket", v))])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req).map(|m| &m.parent).map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "parent",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = crate::google::storage::v2::ListObjectsResponse;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/ListObjects");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::ListObjectsResponse>)
    }

    async fn rewrite_object(
        &self,
        req: crate::model::RewriteObjectRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::RewriteResponse>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new(
                "google.storage.v2.Storage",
                "RewriteObject",
            ));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.storage.v2.Storage/RewriteObject");
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[
                None.or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req)
                            .map(|m| &m.destination_bucket)
                            .map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("bucket", v)),
                None.or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req).map(|m| &m.source_bucket).map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("source_bucket", v)),
            ])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req)
                        .map(|m| &m.destination_bucket)
                        .map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "destination_bucket",
                    "**",
                );
                let builder = builder.maybe_add(
                    Some(&req).map(|m| &m.source_bucket).map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "source_bucket",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = crate::google::storage::v2::RewriteResponse;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/RewriteObject");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::RewriteResponse>)
    }

    async fn move_object(
        &self,
        req: crate::model::MoveObjectRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Object>> {
        use gaxi::{
            grpc::tonic::{Extensions, GrpcMethod},
            prost::ToProto,
        };
        let options = google_cloud_gax::options::internal::set_default_idempotency(options, false);
        let extensions = {
            let mut e = Extensions::new();
            e.insert(GrpcMethod::new("google.storage.v2.Storage", "MoveObject"));
            e
        };
        let path = http::uri::PathAndQuery::from_static("/google.storage.v2.Storage/MoveObject");
        let x_goog_request_params = {
            use gaxi::routing_parameter::Segment;
            gaxi::routing_parameter::format(&[None
                .or_else(|| {
                    gaxi::routing_parameter::value(
                        Some(&req).map(|m| &m.bucket).map(|s| s.as_str()),
                        &[],
                        &[Segment::MultiWildcard],
                        &[],
                    )
                })
                .map(|v| ("bucket", v))])
        };
        if x_goog_request_params.is_empty() {
            use gaxi::path_parameter::PathMismatchBuilder;
            use gaxi::routing_parameter::Segment;
            use google_cloud_gax::error::binding::BindingError;
            let mut paths = Vec::new();
            {
                let builder = PathMismatchBuilder::default();
                let builder = builder.maybe_add(
                    Some(&req).map(|m| &m.bucket).map(|s| s.as_str()),
                    &[Segment::MultiWildcard],
                    "bucket",
                    "**",
                );
                paths.push(builder.build());
            }
            return Err(google_cloud_gax::error::Error::binding(BindingError {
                paths,
            }));
        }

        type TR = crate::google::storage::v2::Object;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            let attributes = gaxi::observability::ClientRequestAttributes::default()
                .set_rpc_method("google.storage.v2.Storage/MoveObject");
            recorder.on_client_request(attributes);
        }
        self.inner
            .execute(
                extensions,
                path,
                req.to_proto().map_err(Error::deser)?,
                options,
                &info::X_GOOG_API_CLIENT_HEADER,
                &x_goog_request_params,
            )
            .await
            .and_then(gaxi::grpc::to_gax_response::<TR, crate::model::Object>)
    }
}