google-cloud-sql-v1 2.5.0

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

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

/// Implements [SqlBackupRunsService](super::stub::SqlBackupRunsService) using a [gaxi::http::ReqwestClient].
#[derive(Clone)]
pub struct SqlBackupRunsService {
    inner: gaxi::http::ReqwestClient,
}

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

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

impl super::stub::SqlBackupRunsService for SqlBackupRunsService {
    async fn delete(
        &self,
        req: crate::model::SqlBackupRunsDeleteRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_id = try_match(Some(&req).map(|m| &m.id), &[Segment::SingleWildcard])?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/backupRuns/{}",
                    var_project, var_instance, var_id,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/backupRuns/{id}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}/backupRuns/{}",
                    var_project, var_instance, var_id,
                );
                let builder = self.inner.builder(Method::DELETE, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::DELETE, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.id),
                        &[Segment::SingleWildcard],
                        "id",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlBackupRunsService/Delete")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn get(
        &self,
        req: crate::model::SqlBackupRunsGetRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::BackupRun>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_id = try_match(Some(&req).map(|m| &m.id), &[Segment::SingleWildcard])?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/backupRuns/{}",
                    var_project, var_instance, var_id,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/backupRuns/{id}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}/backupRuns/{}",
                    var_project, var_instance, var_id,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.id),
                        &[Segment::SingleWildcard],
                        "id",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlBackupRunsService/Get")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn insert(
        &self,
        req: crate::model::SqlBackupRunsInsertRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/backupRuns",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/backupRuns";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlBackupRunsService/Insert")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn list(
        &self,
        req: crate::model::SqlBackupRunsListRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::BackupRunsListResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/backupRuns",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/backupRuns";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = builder.query(&[("maxResults", &req.max_results)]);
                let builder = builder.query(&[("pageToken", &req.page_token)]);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlBackupRunsService/List")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }
}

/// Implements [SqlBackupsService](super::stub::SqlBackupsService) using a [gaxi::http::ReqwestClient].
#[derive(Clone)]
pub struct SqlBackupsService {
    inner: gaxi::http::ReqwestClient,
}

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

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

impl super::stub::SqlBackupsService for SqlBackupsService {
    async fn create_backup(
        &self,
        req: crate::model::CreateBackupRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_parent = try_match(
                    Some(&req).map(|m| &m.parent).map(|s| s.as_str()),
                    &[Segment::Literal("projects/"), Segment::SingleWildcard],
                )?;
                let path = format!("/v1/{}/backups", var_parent,);
                let path_template = "/v1/{parent}/backups";

                let resource_name = format!("//sqladmin.googleapis.com/{}", var_parent,);
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                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::Literal("projects/"), Segment::SingleWildcard],
                        "parent",
                        "projects/*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlBackupsService/CreateBackup")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.backup, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn get_backup(
        &self,
        req: crate::model::GetBackupRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Backup>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_name = try_match(
                    Some(&req).map(|m| &m.name).map(|s| s.as_str()),
                    &[
                        Segment::Literal("projects/"),
                        Segment::SingleWildcard,
                        Segment::Literal("/backups/"),
                        Segment::SingleWildcard,
                    ],
                )?;
                let path = format!("/v1/{}", var_name,);
                let path_template = "/v1/{name}";

                let resource_name = format!("//sqladmin.googleapis.com/{}", var_name,);
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                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::Literal("projects/"),
                            Segment::SingleWildcard,
                            Segment::Literal("/backups/"),
                            Segment::SingleWildcard,
                        ],
                        "name",
                        "projects/*/backups/*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlBackupsService/GetBackup")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn list_backups(
        &self,
        req: crate::model::ListBackupsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListBackupsResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_parent = try_match(
                    Some(&req).map(|m| &m.parent).map(|s| s.as_str()),
                    &[Segment::Literal("projects/"), Segment::SingleWildcard],
                )?;
                let path = format!("/v1/{}/backups", var_parent,);
                let path_template = "/v1/{parent}/backups";

                let resource_name = format!("//sqladmin.googleapis.com/{}", var_parent,);
                let builder = self.inner.builder(Method::GET, path);
                let builder = builder.query(&[("pageSize", &req.page_size)]);
                let builder = builder.query(&[("pageToken", &req.page_token)]);
                let builder = builder.query(&[("filter", &req.filter)]);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                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::Literal("projects/"), Segment::SingleWildcard],
                        "parent",
                        "projects/*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlBackupsService/ListBackups")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn update_backup(
        &self,
        req: crate::model::UpdateBackupRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_backup_name = try_match(
                    Some(&req)
                        .and_then(|m| m.backup.as_ref())
                        .map(|m| &m.name)
                        .map(|s| s.as_str()),
                    &[
                        Segment::Literal("projects/"),
                        Segment::SingleWildcard,
                        Segment::Literal("/backups/"),
                        Segment::SingleWildcard,
                    ],
                )?;
                let path = format!("/v1/{}", var_backup_name,);
                let path_template = "/v1/{backup.name}";

                let resource_name = format!("//sqladmin.googleapis.com/{}", var_backup_name,);
                let builder = self.inner.builder(Method::PATCH, path);
                let builder = (|| {
                    let builder = req
                        .update_mask
                        .as_ref()
                        .map(|p| serde_json::to_value(p).map_err(Error::ser))
                        .transpose()?
                        .into_iter()
                        .fold(builder, |builder, v| {
                            use gaxi::query_parameter::QueryParameter;
                            v.add(builder, "updateMask")
                        });
                    Ok(builder)
                })();
                Some(builder.map(|b| (b, Method::PATCH, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req)
                            .and_then(|m| m.backup.as_ref())
                            .map(|m| &m.name)
                            .map(|s| s.as_str()),
                        &[
                            Segment::Literal("projects/"),
                            Segment::SingleWildcard,
                            Segment::Literal("/backups/"),
                            Segment::SingleWildcard,
                        ],
                        "backup.name",
                        "projects/*/backups/*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlBackupsService/UpdateBackup")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.backup, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn delete_backup(
        &self,
        req: crate::model::DeleteBackupRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_name = try_match(
                    Some(&req).map(|m| &m.name).map(|s| s.as_str()),
                    &[
                        Segment::Literal("projects/"),
                        Segment::SingleWildcard,
                        Segment::Literal("/backups/"),
                        Segment::SingleWildcard,
                    ],
                )?;
                let path = format!("/v1/{}", var_name,);
                let path_template = "/v1/{name}";

                let resource_name = format!("//sqladmin.googleapis.com/{}", var_name,);
                let builder = self.inner.builder(Method::DELETE, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::DELETE, path_template, resource_name)))
            })
            .ok_or_else(|| {
                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::Literal("projects/"),
                            Segment::SingleWildcard,
                            Segment::Literal("/backups/"),
                            Segment::SingleWildcard,
                        ],
                        "name",
                        "projects/*/backups/*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlBackupsService/DeleteBackup")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }
}

/// Implements [SqlConnectService](super::stub::SqlConnectService) using a [gaxi::http::ReqwestClient].
#[derive(Clone)]
pub struct SqlConnectService {
    inner: gaxi::http::ReqwestClient,
}

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

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

impl super::stub::SqlConnectService for SqlConnectService {
    async fn get_connect_settings(
        &self,
        req: crate::model::GetConnectSettingsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ConnectSettings>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/connectSettings",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/connectSettings";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = (|| {
                    let builder = req
                        .read_time
                        .as_ref()
                        .map(|p| serde_json::to_value(p).map_err(Error::ser))
                        .transpose()?
                        .into_iter()
                        .fold(builder, |builder, v| {
                            use gaxi::query_parameter::QueryParameter;
                            v.add(builder, "readTime")
                        });
                    Ok(builder)
                })();
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlConnectService/GetConnectSettings")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn generate_ephemeral_cert(
        &self,
        req: crate::model::GenerateEphemeralCertRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::GenerateEphemeralCertResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}:generateEphemeralCert",
                    var_project, var_instance,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}:generateEphemeralCert";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlConnectService/GenerateEphemeralCert")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(Some(req), &method);
        self.inner.execute(builder, body, options).await
    }
}

/// Implements [SqlDatabasesService](super::stub::SqlDatabasesService) using a [gaxi::http::ReqwestClient].
#[derive(Clone)]
pub struct SqlDatabasesService {
    inner: gaxi::http::ReqwestClient,
}

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

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

impl super::stub::SqlDatabasesService for SqlDatabasesService {
    async fn delete(
        &self,
        req: crate::model::SqlDatabasesDeleteRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_database = try_match(
                    Some(&req).map(|m| &m.database).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/databases/{}",
                    var_project, var_instance, var_database,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/databases/{database}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}/databases/{}",
                    var_project, var_instance, var_database,
                );
                let builder = self.inner.builder(Method::DELETE, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::DELETE, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.database).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "database",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlDatabasesService/Delete")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn get(
        &self,
        req: crate::model::SqlDatabasesGetRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Database>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_database = try_match(
                    Some(&req).map(|m| &m.database).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/databases/{}",
                    var_project, var_instance, var_database,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/databases/{database}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}/databases/{}",
                    var_project, var_instance, var_database,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.database).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "database",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlDatabasesService/Get")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn insert(
        &self,
        req: crate::model::SqlDatabasesInsertRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/databases",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/databases";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlDatabasesService/Insert")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn list(
        &self,
        req: crate::model::SqlDatabasesListRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::DatabasesListResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/databases",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/databases";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlDatabasesService/List")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn patch(
        &self,
        req: crate::model::SqlDatabasesUpdateRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_database = try_match(
                    Some(&req).map(|m| &m.database).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/databases/{}",
                    var_project, var_instance, var_database,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/databases/{database}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}/databases/{}",
                    var_project, var_instance, var_database,
                );
                let builder = self.inner.builder(Method::PATCH, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::PATCH, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.database).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "database",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlDatabasesService/Patch")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn update(
        &self,
        req: crate::model::SqlDatabasesUpdateRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_database = try_match(
                    Some(&req).map(|m| &m.database).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/databases/{}",
                    var_project, var_instance, var_database,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/databases/{database}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}/databases/{}",
                    var_project, var_instance, var_database,
                );
                let builder = self.inner.builder(Method::PUT, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::PUT, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.database).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "database",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlDatabasesService/Update")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }
}

/// Implements [SqlFlagsService](super::stub::SqlFlagsService) using a [gaxi::http::ReqwestClient].
#[derive(Clone)]
pub struct SqlFlagsService {
    inner: gaxi::http::ReqwestClient,
}

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

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

impl super::stub::SqlFlagsService for SqlFlagsService {
    async fn list(
        &self,
        req: crate::model::SqlFlagsListRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::FlagsListResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template) = None
            .or_else(|| {
                let path = "/v1/flags".to_string();
                let path_template = "/v1/flags";

                let builder = self.inner.builder(Method::GET, path);
                let builder = builder.query(&[("databaseVersion", &req.database_version)]);
                let builder = req
                    .flag_scope
                    .iter()
                    .fold(builder, |builder, p| builder.query(&[("flagScope", p)]));
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlFlagsService/List")
                    .set_url_template(_path_template),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }
}

/// Implements [SqlInstancesService](super::stub::SqlInstancesService) using a [gaxi::http::ReqwestClient].
#[derive(Clone)]
pub struct SqlInstancesService {
    inner: gaxi::http::ReqwestClient,
}

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

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

impl super::stub::SqlInstancesService for SqlInstancesService {
    async fn add_server_ca(
        &self,
        req: crate::model::SqlInstancesAddServerCaRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/addServerCa",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/addServerCa";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/AddServerCa")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn add_server_certificate(
        &self,
        req: crate::model::SqlInstancesAddServerCertificateRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/addServerCertificate",
                    var_project, var_instance,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/addServerCertificate";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/AddServerCertificate")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn add_entra_id_certificate(
        &self,
        req: crate::model::SqlInstancesAddEntraIdCertificateRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/addEntraIdCertificate",
                    var_project, var_instance,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/addEntraIdCertificate";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/AddEntraIdCertificate")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn clone(
        &self,
        req: crate::model::SqlInstancesCloneRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/clone",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/clone";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/Clone")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn delete(
        &self,
        req: crate::model::SqlInstancesDeleteRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!("/v1/projects/{}/instances/{}", var_project, var_instance,);
                let path_template = "/v1/projects/{project}/instances/{instance}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::DELETE, path);
                let builder = (|| {
                    let builder = req.enable_final_backup.iter().fold(builder, |builder, p| {
                        builder.query(&[("enableFinalBackup", p)])
                    });
                    let builder = req
                        .final_backup_ttl_days()
                        .iter()
                        .fold(builder, |builder, p| {
                            builder.query(&[("finalBackupTtlDays", p)])
                        });
                    let builder = req
                        .final_backup_expiry_time()
                        .map(|p| serde_json::to_value(p).map_err(Error::ser))
                        .transpose()?
                        .into_iter()
                        .fold(builder, |builder, p| {
                            use gaxi::query_parameter::QueryParameter;
                            p.add(builder, "finalBackupExpiryTime")
                        });
                    let builder =
                        builder.query(&[("finalBackupDescription", &req.final_backup_description)]);
                    Ok(builder)
                })();
                Some(builder.map(|b| (b, Method::DELETE, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/Delete")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn demote_master(
        &self,
        req: crate::model::SqlInstancesDemoteMasterRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/demoteMaster",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/demoteMaster";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/DemoteMaster")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn demote(
        &self,
        req: crate::model::SqlInstancesDemoteRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/demote",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/demote";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/Demote")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn export(
        &self,
        req: crate::model::SqlInstancesExportRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/export",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/export";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/Export")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn failover(
        &self,
        req: crate::model::SqlInstancesFailoverRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/failover",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/failover";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/Failover")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn reencrypt(
        &self,
        req: crate::model::SqlInstancesReencryptRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/reencrypt",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/reencrypt";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/Reencrypt")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn get(
        &self,
        req: crate::model::SqlInstancesGetRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::DatabaseInstance>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!("/v1/projects/{}/instances/{}", var_project, var_instance,);
                let path_template = "/v1/projects/{project}/instances/{instance}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/Get")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn import(
        &self,
        req: crate::model::SqlInstancesImportRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/import",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/import";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/Import")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn insert(
        &self,
        req: crate::model::SqlInstancesInsertRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!("/v1/projects/{}/instances", var_project,);
                let path_template = "/v1/projects/{project}/instances";

                let resource_name = format!("//sqladmin.googleapis.com/projects/{}", var_project,);
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/Insert")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn list(
        &self,
        req: crate::model::SqlInstancesListRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::InstancesListResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!("/v1/projects/{}/instances", var_project,);
                let path_template = "/v1/projects/{project}/instances";

                let resource_name = format!("//sqladmin.googleapis.com/projects/{}", var_project,);
                let builder = self.inner.builder(Method::GET, path);
                let builder = builder.query(&[("filter", &req.filter)]);
                let builder = builder.query(&[("maxResults", &req.max_results)]);
                let builder = builder.query(&[("pageToken", &req.page_token)]);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/List")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn list_server_cas(
        &self,
        req: crate::model::SqlInstancesListServerCasRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::InstancesListServerCasResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/listServerCas",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/listServerCas";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/ListServerCas")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn list_server_certificates(
        &self,
        req: crate::model::SqlInstancesListServerCertificatesRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::InstancesListServerCertificatesResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/listServerCertificates",
                    var_project, var_instance,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/listServerCertificates";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method(
                        "google.cloud.sql.v1.SqlInstancesService/ListServerCertificates",
                    )
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn list_entra_id_certificates(
        &self,
        req: crate::model::SqlInstancesListEntraIdCertificatesRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::InstancesListEntraIdCertificatesResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/listEntraIdCertificates",
                    var_project, var_instance,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/listEntraIdCertificates";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method(
                        "google.cloud.sql.v1.SqlInstancesService/ListEntraIdCertificates",
                    )
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn patch(
        &self,
        req: crate::model::SqlInstancesPatchRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!("/v1/projects/{}/instances/{}", var_project, var_instance,);
                let path_template = "/v1/projects/{project}/instances/{instance}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::PATCH, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::PATCH, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/Patch")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn promote_replica(
        &self,
        req: crate::model::SqlInstancesPromoteReplicaRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/promoteReplica",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/promoteReplica";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = builder.query(&[("failover", &req.failover)]);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/PromoteReplica")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn switchover(
        &self,
        req: crate::model::SqlInstancesSwitchoverRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/switchover",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/switchover";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = (|| {
                    let builder = req
                        .db_timeout
                        .as_ref()
                        .map(|p| serde_json::to_value(p).map_err(Error::ser))
                        .transpose()?
                        .into_iter()
                        .fold(builder, |builder, v| {
                            use gaxi::query_parameter::QueryParameter;
                            v.add(builder, "dbTimeout")
                        });
                    Ok(builder)
                })();
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/Switchover")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn reset_ssl_config(
        &self,
        req: crate::model::SqlInstancesResetSslConfigRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/resetSslConfig",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/resetSslConfig";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = builder.query(&[("mode", &req.mode)]);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/ResetSslConfig")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn restart(
        &self,
        req: crate::model::SqlInstancesRestartRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/restart",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/restart";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/Restart")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn restore_backup(
        &self,
        req: crate::model::SqlInstancesRestoreBackupRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/restoreBackup",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/restoreBackup";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/RestoreBackup")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn rotate_server_ca(
        &self,
        req: crate::model::SqlInstancesRotateServerCaRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/rotateServerCa",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/rotateServerCa";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/RotateServerCa")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn rotate_server_certificate(
        &self,
        req: crate::model::SqlInstancesRotateServerCertificateRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/rotateServerCertificate",
                    var_project, var_instance,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/rotateServerCertificate";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method(
                        "google.cloud.sql.v1.SqlInstancesService/RotateServerCertificate",
                    )
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn rotate_entra_id_certificate(
        &self,
        req: crate::model::SqlInstancesRotateEntraIdCertificateRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/rotateEntraIdCertificate",
                    var_project, var_instance,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/rotateEntraIdCertificate";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method(
                        "google.cloud.sql.v1.SqlInstancesService/RotateEntraIdCertificate",
                    )
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn start_replica(
        &self,
        req: crate::model::SqlInstancesStartReplicaRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/startReplica",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/startReplica";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/StartReplica")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn stop_replica(
        &self,
        req: crate::model::SqlInstancesStopReplicaRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/stopReplica",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/stopReplica";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/StopReplica")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn truncate_log(
        &self,
        req: crate::model::SqlInstancesTruncateLogRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/truncateLog",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/truncateLog";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/TruncateLog")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn update(
        &self,
        req: crate::model::SqlInstancesUpdateRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!("/v1/projects/{}/instances/{}", var_project, var_instance,);
                let path_template = "/v1/projects/{project}/instances/{instance}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::PUT, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::PUT, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/Update")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn create_ephemeral(
        &self,
        req: crate::model::SqlInstancesCreateEphemeralCertRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SslCert>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/createEphemeral",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/createEphemeral";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/CreateEphemeral")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn reschedule_maintenance(
        &self,
        req: crate::model::SqlInstancesRescheduleMaintenanceRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/rescheduleMaintenance",
                    var_project, var_instance,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/rescheduleMaintenance";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/RescheduleMaintenance")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn verify_external_sync_settings(
        &self,
        req: crate::model::SqlInstancesVerifyExternalSyncSettingsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SqlInstancesVerifyExternalSyncSettingsResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/verifyExternalSyncSettings",
                    var_project, var_instance,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/verifyExternalSyncSettings";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method(
                        "google.cloud.sql.v1.SqlInstancesService/VerifyExternalSyncSettings",
                    )
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(Some(req), &method);
        self.inner.execute(builder, body, options).await
    }

    async fn start_external_sync(
        &self,
        req: crate::model::SqlInstancesStartExternalSyncRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/startExternalSync",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/startExternalSync";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/StartExternalSync")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(Some(req), &method);
        self.inner.execute(builder, body, options).await
    }

    async fn perform_disk_shrink(
        &self,
        req: crate::model::SqlInstancesPerformDiskShrinkRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/performDiskShrink",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/performDiskShrink";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/PerformDiskShrink")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn get_disk_shrink_config(
        &self,
        req: crate::model::SqlInstancesGetDiskShrinkConfigRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SqlInstancesGetDiskShrinkConfigResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/getDiskShrinkConfig",
                    var_project, var_instance,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/getDiskShrinkConfig";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/GetDiskShrinkConfig")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn reset_replica_size(
        &self,
        req: crate::model::SqlInstancesResetReplicaSizeRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/resetReplicaSize",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/resetReplicaSize";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/ResetReplicaSize")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(Some(req), &method);
        self.inner.execute(builder, body, options).await
    }

    async fn get_latest_recovery_time(
        &self,
        req: crate::model::SqlInstancesGetLatestRecoveryTimeRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SqlInstancesGetLatestRecoveryTimeResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/getLatestRecoveryTime",
                    var_project, var_instance,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/getLatestRecoveryTime";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = (|| {
                    let builder = req
                        .source_instance_deletion_time
                        .as_ref()
                        .map(|p| serde_json::to_value(p).map_err(Error::ser))
                        .transpose()?
                        .into_iter()
                        .fold(builder, |builder, v| {
                            use gaxi::query_parameter::QueryParameter;
                            v.add(builder, "sourceInstanceDeletionTime")
                        });
                    Ok(builder)
                })();
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/GetLatestRecoveryTime")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn execute_sql(
        &self,
        req: crate::model::SqlInstancesExecuteSqlRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SqlInstancesExecuteSqlResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/executeSql",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/executeSql";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/ExecuteSql")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn acquire_ssrs_lease(
        &self,
        req: crate::model::SqlInstancesAcquireSsrsLeaseRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SqlInstancesAcquireSsrsLeaseResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/acquireSsrsLease",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/acquireSsrsLease";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/AcquireSsrsLease")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn release_ssrs_lease(
        &self,
        req: crate::model::SqlInstancesReleaseSsrsLeaseRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SqlInstancesReleaseSsrsLeaseResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/releaseSsrsLease",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/releaseSsrsLease";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/ReleaseSsrsLease")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn pre_check_major_version_upgrade(
        &self,
        req: crate::model::SqlInstancesPreCheckMajorVersionUpgradeRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/preCheckMajorVersionUpgrade",
                    var_project, var_instance,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/preCheckMajorVersionUpgrade";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method(
                        "google.cloud.sql.v1.SqlInstancesService/PreCheckMajorVersionUpgrade",
                    )
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn point_in_time_restore(
        &self,
        req: crate::model::SqlInstancesPointInTimeRestoreRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_parent = try_match(
                    Some(&req).map(|m| &m.parent).map(|s| s.as_str()),
                    &[Segment::Literal("projects/"), Segment::SingleWildcard],
                )?;
                let path = format!("/v1/{}:pointInTimeRestore", var_parent,);
                let path_template = "/v1/{parent}:pointInTimeRestore";

                let resource_name = format!("//sqladmin.googleapis.com/{}", var_parent,);
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                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::Literal("projects/"), Segment::SingleWildcard],
                        "parent",
                        "projects/*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlInstancesService/PointInTimeRestore")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.context, &method);
        self.inner.execute(builder, body, options).await
    }
}

/// Implements [SqlOperationsService](super::stub::SqlOperationsService) using a [gaxi::http::ReqwestClient].
#[derive(Clone)]
pub struct SqlOperationsService {
    inner: gaxi::http::ReqwestClient,
}

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

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

impl super::stub::SqlOperationsService for SqlOperationsService {
    async fn get(
        &self,
        req: crate::model::SqlOperationsGetRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_operation = try_match(
                    Some(&req).map(|m| &m.operation).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!("/v1/projects/{}/operations/{}", var_project, var_operation,);
                let path_template = "/v1/projects/{project}/operations/{operation}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/operations/{}",
                    var_project, var_operation,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.operation).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "operation",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlOperationsService/Get")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn list(
        &self,
        req: crate::model::SqlOperationsListRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::OperationsListResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!("/v1/projects/{}/operations", var_project,);
                let path_template = "/v1/projects/{project}/operations";

                let resource_name = format!("//sqladmin.googleapis.com/projects/{}", var_project,);
                let builder = self.inner.builder(Method::GET, path);
                let builder = builder.query(&[("instance", &req.instance)]);
                let builder = builder.query(&[("maxResults", &req.max_results)]);
                let builder = builder.query(&[("pageToken", &req.page_token)]);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlOperationsService/List")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn cancel(
        &self,
        req: crate::model::SqlOperationsCancelRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<()>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_operation = try_match(
                    Some(&req).map(|m| &m.operation).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/operations/{}/cancel",
                    var_project, var_operation,
                );
                let path_template = "/v1/projects/{project}/operations/{operation}/cancel";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/operations/{}",
                    var_project, var_operation,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.operation).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "operation",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlOperationsService/Cancel")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner
            .execute(builder, body, options)
            .await
            .map(|r: crate::Response<wkt::Empty>| {
                let (parts, _) = r.into_parts();
                crate::Response::from_parts(parts, ())
            })
    }
}

/// Implements [SqlSslCertsService](super::stub::SqlSslCertsService) using a [gaxi::http::ReqwestClient].
#[derive(Clone)]
pub struct SqlSslCertsService {
    inner: gaxi::http::ReqwestClient,
}

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

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

impl super::stub::SqlSslCertsService for SqlSslCertsService {
    async fn delete(
        &self,
        req: crate::model::SqlSslCertsDeleteRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_sha1_fingerprint = try_match(
                    Some(&req).map(|m| &m.sha1_fingerprint).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/sslCerts/{}",
                    var_project, var_instance, var_sha1_fingerprint,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/sslCerts/{sha1_fingerprint}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}/sslCerts/{}",
                    var_project, var_instance, var_sha1_fingerprint,
                );
                let builder = self.inner.builder(Method::DELETE, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::DELETE, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.sha1_fingerprint).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "sha1_fingerprint",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlSslCertsService/Delete")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn get(
        &self,
        req: crate::model::SqlSslCertsGetRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SslCert>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_sha1_fingerprint = try_match(
                    Some(&req).map(|m| &m.sha1_fingerprint).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/sslCerts/{}",
                    var_project, var_instance, var_sha1_fingerprint,
                );
                let path_template =
                    "/v1/projects/{project}/instances/{instance}/sslCerts/{sha1_fingerprint}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}/sslCerts/{}",
                    var_project, var_instance, var_sha1_fingerprint,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.sha1_fingerprint).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "sha1_fingerprint",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlSslCertsService/Get")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn insert(
        &self,
        req: crate::model::SqlSslCertsInsertRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SslCertsInsertResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/sslCerts",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/sslCerts";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlSslCertsService/Insert")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn list(
        &self,
        req: crate::model::SqlSslCertsListRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SslCertsListResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/sslCerts",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/sslCerts";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlSslCertsService/List")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }
}

/// Implements [SqlTiersService](super::stub::SqlTiersService) using a [gaxi::http::ReqwestClient].
#[derive(Clone)]
pub struct SqlTiersService {
    inner: gaxi::http::ReqwestClient,
}

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

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

impl super::stub::SqlTiersService for SqlTiersService {
    async fn list(
        &self,
        req: crate::model::SqlTiersListRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::TiersListResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!("/v1/projects/{}/tiers", var_project,);
                let path_template = "/v1/projects/{project}/tiers";

                let resource_name = format!("//sqladmin.googleapis.com/projects/{}", var_project,);
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlTiersService/List")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }
}

/// Implements [SqlUsersService](super::stub::SqlUsersService) using a [gaxi::http::ReqwestClient].
#[derive(Clone)]
pub struct SqlUsersService {
    inner: gaxi::http::ReqwestClient,
}

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

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

impl super::stub::SqlUsersService for SqlUsersService {
    async fn delete(
        &self,
        req: crate::model::SqlUsersDeleteRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/users",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/users";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::DELETE, path);
                let builder = builder.query(&[("host", &req.host)]);
                let builder = builder.query(&[("name", &req.name)]);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::DELETE, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlUsersService/Delete")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn get(
        &self,
        req: crate::model::SqlUsersGetRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::User>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_name = try_match(
                    Some(&req).map(|m| &m.name).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/users/{}",
                    var_project, var_instance, var_name,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/users/{name}";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}/users/{}",
                    var_project, var_instance, var_name,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = builder.query(&[("host", &req.host)]);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.name).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "name",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlUsersService/Get")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn insert(
        &self,
        req: crate::model::SqlUsersInsertRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/users",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/users";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlUsersService/Insert")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn list(
        &self,
        req: crate::model::SqlUsersListRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::UsersListResponse>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/users",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/users";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::GET, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::GET, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlUsersService/List")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(None::<gaxi::http::NoBody>, &method);
        self.inner.execute(builder, body, options).await
    }

    async fn update(
        &self,
        req: crate::model::SqlUsersUpdateRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Operation>> {
        use gaxi::http::reqwest::{HeaderValue, Method};
        use gaxi::path_parameter::PathMismatchBuilder;
        use gaxi::path_parameter::try_match;
        use gaxi::routing_parameter::Segment;
        use google_cloud_gax::error::binding::BindingError;
        let (builder, method, _path_template, _resource_name) = None
            .or_else(|| {
                let var_project = try_match(
                    Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let var_instance = try_match(
                    Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!(
                    "/v1/projects/{}/instances/{}/users",
                    var_project, var_instance,
                );
                let path_template = "/v1/projects/{project}/instances/{instance}/users";

                let resource_name = format!(
                    "//sqladmin.googleapis.com/projects/{}/instances/{}",
                    var_project, var_instance,
                );
                let builder = self.inner.builder(Method::PUT, path);
                let builder = builder.query(&[("host", &req.host)]);
                let builder = builder.query(&[("name", &req.name)]);
                let builder = req
                    .database_roles
                    .iter()
                    .fold(builder, |builder, p| builder.query(&[("databaseRoles", p)]));
                let builder = req
                    .revoke_existing_roles
                    .iter()
                    .fold(builder, |builder, p| {
                        builder.query(&[("revokeExistingRoles", p)])
                    });
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::PUT, path_template, resource_name)))
            })
            .ok_or_else(|| {
                let mut paths = Vec::new();
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.project).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "project",
                        "*",
                    );
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.instance).map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "instance",
                        "*",
                    );
                    paths.push(builder.build());
                }
                google_cloud_gax::error::Error::binding(BindingError { paths })
            })??;
        if let Some(recorder) = gaxi::observability::RequestRecorder::current() {
            recorder.on_client_request(
                gaxi::observability::ClientRequestAttributes::default()
                    .set_rpc_method("google.cloud.sql.v1.SqlUsersService/Update")
                    .set_url_template(_path_template)
                    .set_resource_name(_resource_name),
            );
        }
        let options = google_cloud_gax::options::internal::set_default_idempotency(
            options,
            gaxi::http::default_idempotency(&method),
        );
        let builder = builder.query(&[("$alt", "json;enum-encoding=int")]).header(
            "x-goog-api-client",
            HeaderValue::from_static(&crate::info::X_GOOG_API_CLIENT_HEADER),
        );
        let body = gaxi::http::handle_empty(req.body, &method);
        self.inner.execute(builder, body, options).await
    }
}