google-maps-geocode-v4 1.0.0

// Copyright 2026 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 [DestinationService](super::stub::DestinationService) using a [gaxi::http::ReqwestClient].
#[derive(Clone)]
pub struct DestinationService {
    inner: gaxi::http::ReqwestClient,
}

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

impl DestinationService {
    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::DestinationService for DestinationService {
    async fn search_destinations(
        &self,
        req: crate::model::SearchDestinationsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SearchDestinationsResponse>> {
        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 = "/v4/geocode/destinations".to_string();
                let path_template = "/v4/geocode/destinations";

                let builder = self.inner.builder(Method::POST, path);
                let builder = Ok(builder);
                Some(builder.map(|b| (b, Method::POST, 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.maps.geocode.v4.DestinationService/SearchDestinations")
                    .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(Some(req), &method);
        self.inner.execute(builder, body, options).await
    }
}

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

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

impl GeocodeService {
    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::GeocodeService for GeocodeService {
    async fn geocode_address(
        &self,
        req: crate::model::GeocodeAddressRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::GeocodeAddressResponse>> {
        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) = None
            .or_else(|| {
                let path = "/v4/geocode/address".to_string();
                let path_template = "/v4/geocode/address";

                let builder = self.inner.builder(Method::GET, path);
                let builder = (|| {
                    let builder = req
                        .address_query()
                        .iter()
                        .fold(builder, |builder, p| builder.query(&[("addressQuery", p)]));
                    let builder = req
                        .address()
                        .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, "address")
                        });
                    let builder = req
                        .location_bias
                        .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, "locationBias")
                        });
                    let builder = builder.query(&[("languageCode", &req.language_code)]);
                    let builder = builder.query(&[("regionCode", &req.region_code)]);
                    Ok(builder)
                })();
                Some(builder.map(|b| (b, Method::GET, path_template)))
            })
            .or_else(|| {
                let var_address_query = try_match(
                    Some(&req)
                        .and_then(|m| m.address_query())
                        .map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!("/v4/geocode/address/{}", var_address_query,);
                let path_template = "/v4/geocode/address/{address_query}";

                let builder = self.inner.builder(Method::GET, path);
                let builder = (|| {
                    let builder = req
                        .address()
                        .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, "address")
                        });
                    let builder = req
                        .location_bias
                        .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, "locationBias")
                        });
                    let builder = builder.query(&[("languageCode", &req.language_code)]);
                    let builder = builder.query(&[("regionCode", &req.region_code)]);
                    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());
                }
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req)
                            .and_then(|m| m.address_query())
                            .map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "address_query",
                        "*",
                    );
                    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.maps.geocode.v4.GeocodeService/GeocodeAddress")
                    .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
    }

    async fn geocode_location(
        &self,
        req: crate::model::GeocodeLocationRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::GeocodeLocationResponse>> {
        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) = None
            .or_else(|| {
                let path = "/v4/geocode/location".to_string();
                let path_template = "/v4/geocode/location";

                let builder = self.inner.builder(Method::GET, path);
                let builder = (|| {
                    let builder = req
                        .location_query()
                        .iter()
                        .fold(builder, |builder, p| builder.query(&[("locationQuery", p)]));
                    let builder = req
                        .location()
                        .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, "location")
                        });
                    let builder = builder.query(&[("languageCode", &req.language_code)]);
                    let builder = builder.query(&[("regionCode", &req.region_code)]);
                    let builder = req
                        .types
                        .iter()
                        .fold(builder, |builder, p| builder.query(&[("types", p)]));
                    let builder = req
                        .granularity
                        .iter()
                        .fold(builder, |builder, p| builder.query(&[("granularity", p)]));
                    Ok(builder)
                })();
                Some(builder.map(|b| (b, Method::GET, path_template)))
            })
            .or_else(|| {
                let var_location_query = try_match(
                    Some(&req)
                        .and_then(|m| m.location_query())
                        .map(|s| s.as_str()),
                    &[Segment::SingleWildcard],
                )?;
                let path = format!("/v4/geocode/location/{}", var_location_query,);
                let path_template = "/v4/geocode/location/{location_query}";

                let builder = self.inner.builder(Method::GET, path);
                let builder = (|| {
                    let builder = req
                        .location()
                        .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, "location")
                        });
                    let builder = builder.query(&[("languageCode", &req.language_code)]);
                    let builder = builder.query(&[("regionCode", &req.region_code)]);
                    let builder = req
                        .types
                        .iter()
                        .fold(builder, |builder, p| builder.query(&[("types", p)]));
                    let builder = req
                        .granularity
                        .iter()
                        .fold(builder, |builder, p| builder.query(&[("granularity", p)]));
                    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());
                }
                {
                    let builder = PathMismatchBuilder::default();
                    let builder = builder.maybe_add(
                        Some(&req)
                            .and_then(|m| m.location_query())
                            .map(|s| s.as_str()),
                        &[Segment::SingleWildcard],
                        "location_query",
                        "*",
                    );
                    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.maps.geocode.v4.GeocodeService/GeocodeLocation")
                    .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
    }

    async fn geocode_place(
        &self,
        req: crate::model::GeocodePlaceRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::GeocodeResult>> {
        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) = None
            .or_else(|| {
                let var_place = try_match(
                    Some(&req).map(|m| &m.place).map(|s| s.as_str()),
                    &[Segment::Literal("places/"), Segment::SingleWildcard],
                )?;
                let path = format!("/v4/geocode/{}", var_place,);
                let path_template = "/v4/geocode/{place}";

                let builder = self.inner.builder(Method::GET, path);
                let builder = builder.query(&[("languageCode", &req.language_code)]);
                let builder = builder.query(&[("regionCode", &req.region_code)]);
                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();
                    let builder = builder.maybe_add(
                        Some(&req).map(|m| &m.place).map(|s| s.as_str()),
                        &[Segment::Literal("places/"), Segment::SingleWildcard],
                        "place",
                        "places/*",
                    );
                    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.maps.geocode.v4.GeocodeService/GeocodePlace")
                    .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
    }
}