google-maps-solar-v1 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 [Solar](super::stub::Solar) using a [gaxi::http::ReqwestClient].
#[derive(Clone)]
pub struct Solar {
    inner: gaxi::http::ReqwestClient,
}

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

impl Solar {
    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::Solar for Solar {
    async fn find_closest_building_insights(
        &self,
        req: crate::model::FindClosestBuildingInsightsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::BuildingInsights>> {
        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/buildingInsights:findClosest".to_string();
                let path_template = "/v1/buildingInsights:findClosest";

                let builder = self.inner.builder(Method::GET, path);
                let builder = (|| {
                    let builder = req
                        .location
                        .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, "location")
                        });
                    let builder = builder.query(&[("requiredQuality", &req.required_quality)]);
                    let builder =
                        builder.query(&[("exactQualityRequired", &req.exact_quality_required)]);
                    let builder = req
                        .experiments
                        .iter()
                        .fold(builder, |builder, p| builder.query(&[("experiments", 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());
                }
                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.solar.v1.Solar/FindClosestBuildingInsights")
                    .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 get_data_layers(
        &self,
        req: crate::model::GetDataLayersRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::DataLayers>> {
        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/dataLayers:get".to_string();
                let path_template = "/v1/dataLayers:get";

                let builder = self.inner.builder(Method::GET, path);
                let builder = (|| {
                    let builder = req
                        .location
                        .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, "location")
                        });
                    let builder = builder.query(&[("radiusMeters", &req.radius_meters)]);
                    let builder = builder.query(&[("view", &req.view)]);
                    let builder = builder.query(&[("requiredQuality", &req.required_quality)]);
                    let builder = builder.query(&[("pixelSizeMeters", &req.pixel_size_meters)]);
                    let builder =
                        builder.query(&[("exactQualityRequired", &req.exact_quality_required)]);
                    let builder = req
                        .experiments
                        .iter()
                        .fold(builder, |builder, p| builder.query(&[("experiments", 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());
                }
                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.solar.v1.Solar/GetDataLayers")
                    .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 get_geo_tiff(
        &self,
        req: crate::model::GetGeoTiffRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<google_cloud_api::model::HttpBody>> {
        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/geoTiff:get".to_string();
                let path_template = "/v1/geoTiff:get";

                let builder = self.inner.builder(Method::GET, path);
                let builder = builder.query(&[("id", &req.id)]);
                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.maps.solar.v1.Solar/GetGeoTiff")
                    .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
    }
}