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(rustdoc::bare_urls)]
#![allow(rustdoc::broken_intra_doc_links)]
#![allow(rustdoc::invalid_html_tags)]
#![allow(rustdoc::redundant_explicit_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gaxi;
extern crate google_cloud_api;
extern crate google_cloud_gax;
extern crate google_cloud_type;
extern crate serde;
extern crate serde_json;
extern crate serde_with;
extern crate std;
extern crate tracing;
extern crate wkt;

mod debug;
mod deserialize;
mod serialize;

/// Request message for `Solar.FindClosestBuildingInsights`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FindClosestBuildingInsightsRequest {
    /// Required. The longitude and latitude from which the API looks for the
    /// nearest known building.
    pub location: std::option::Option<google_cloud_type::model::LatLng>,

    /// Optional. The minimum quality level allowed in the results. No result with
    /// lower quality than this will be returned. Not specifying this is
    /// equivalent to restricting to HIGH quality only.
    pub required_quality: crate::model::ImageryQuality,

    /// Optional. Whether to require exact quality of the imagery.
    /// If set to false, the `required_quality` field is interpreted as the minimum
    /// required quality, such that HIGH quality imagery may be returned when
    /// `required_quality` is set to MEDIUM.  If set to true, `required_quality`
    /// is interpreted as the exact required quality and only `MEDIUM` quality
    /// imagery is returned if `required_quality` is set to `MEDIUM`.
    pub exact_quality_required: bool,

    /// Optional. Specifies the pre-GA features to enable.
    pub experiments: std::vec::Vec<crate::model::Experiment>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FindClosestBuildingInsightsRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [location][crate::model::FindClosestBuildingInsightsRequest::location].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FindClosestBuildingInsightsRequest;
    /// use google_cloud_type::model::LatLng;
    /// let x = FindClosestBuildingInsightsRequest::new().set_location(LatLng::default()/* use setters */);
    /// ```
    pub fn set_location<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.location = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [location][crate::model::FindClosestBuildingInsightsRequest::location].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FindClosestBuildingInsightsRequest;
    /// use google_cloud_type::model::LatLng;
    /// let x = FindClosestBuildingInsightsRequest::new().set_or_clear_location(Some(LatLng::default()/* use setters */));
    /// let x = FindClosestBuildingInsightsRequest::new().set_or_clear_location(None::<LatLng>);
    /// ```
    pub fn set_or_clear_location<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.location = v.map(|x| x.into());
        self
    }

    /// Sets the value of [required_quality][crate::model::FindClosestBuildingInsightsRequest::required_quality].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FindClosestBuildingInsightsRequest;
    /// use google_maps_solar_v1::model::ImageryQuality;
    /// let x0 = FindClosestBuildingInsightsRequest::new().set_required_quality(ImageryQuality::High);
    /// let x1 = FindClosestBuildingInsightsRequest::new().set_required_quality(ImageryQuality::Medium);
    /// let x2 = FindClosestBuildingInsightsRequest::new().set_required_quality(ImageryQuality::Low);
    /// ```
    pub fn set_required_quality<T: std::convert::Into<crate::model::ImageryQuality>>(
        mut self,
        v: T,
    ) -> Self {
        self.required_quality = v.into();
        self
    }

    /// Sets the value of [exact_quality_required][crate::model::FindClosestBuildingInsightsRequest::exact_quality_required].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FindClosestBuildingInsightsRequest;
    /// let x = FindClosestBuildingInsightsRequest::new().set_exact_quality_required(true);
    /// ```
    pub fn set_exact_quality_required<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.exact_quality_required = v.into();
        self
    }

    /// Sets the value of [experiments][crate::model::FindClosestBuildingInsightsRequest::experiments].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FindClosestBuildingInsightsRequest;
    /// use google_maps_solar_v1::model::Experiment;
    /// let x = FindClosestBuildingInsightsRequest::new().set_experiments([
    ///     Experiment::ExpandedCoverage,
    /// ]);
    /// ```
    pub fn set_experiments<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Experiment>,
    {
        use std::iter::Iterator;
        self.experiments = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for FindClosestBuildingInsightsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.FindClosestBuildingInsightsRequest"
    }
}

/// A bounding box in lat/lng coordinates.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LatLngBox {
    /// The southwest corner of the box.
    pub sw: std::option::Option<google_cloud_type::model::LatLng>,

    /// The northeast corner of the box.
    pub ne: std::option::Option<google_cloud_type::model::LatLng>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl LatLngBox {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [sw][crate::model::LatLngBox::sw].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::LatLngBox;
    /// use google_cloud_type::model::LatLng;
    /// let x = LatLngBox::new().set_sw(LatLng::default()/* use setters */);
    /// ```
    pub fn set_sw<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.sw = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [sw][crate::model::LatLngBox::sw].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::LatLngBox;
    /// use google_cloud_type::model::LatLng;
    /// let x = LatLngBox::new().set_or_clear_sw(Some(LatLng::default()/* use setters */));
    /// let x = LatLngBox::new().set_or_clear_sw(None::<LatLng>);
    /// ```
    pub fn set_or_clear_sw<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.sw = v.map(|x| x.into());
        self
    }

    /// Sets the value of [ne][crate::model::LatLngBox::ne].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::LatLngBox;
    /// use google_cloud_type::model::LatLng;
    /// let x = LatLngBox::new().set_ne(LatLng::default()/* use setters */);
    /// ```
    pub fn set_ne<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.ne = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [ne][crate::model::LatLngBox::ne].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::LatLngBox;
    /// use google_cloud_type::model::LatLng;
    /// let x = LatLngBox::new().set_or_clear_ne(Some(LatLng::default()/* use setters */));
    /// let x = LatLngBox::new().set_or_clear_ne(None::<LatLng>);
    /// ```
    pub fn set_or_clear_ne<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.ne = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for LatLngBox {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.LatLngBox"
    }
}

/// Response message for `Solar.FindClosestBuildingInsights`.
/// Information about the location, dimensions, and solar potential of a
/// building.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BuildingInsights {
    /// The resource name for the building, of the format `buildings/{place_id}`.
    pub name: std::string::String,

    /// A point near the center of the building.
    pub center: std::option::Option<google_cloud_type::model::LatLng>,

    /// The bounding box of the building.
    pub bounding_box: std::option::Option<crate::model::LatLngBox>,

    /// Date that the underlying imagery was acquired. This is approximate.
    pub imagery_date: std::option::Option<google_cloud_type::model::Date>,

    /// When processing was completed on this imagery.
    pub imagery_processed_date: std::option::Option<google_cloud_type::model::Date>,

    /// Postal code (e.g., US zip code) this building is contained by.
    pub postal_code: std::string::String,

    /// Administrative area 1 (e.g., in the US, the state) that contains this
    /// building. For example, in the US, the abbreviation might be "MA" or "CA."
    pub administrative_area: std::string::String,

    /// Statistical area (e.g., US census tract) this building is in.
    pub statistical_area: std::string::String,

    /// Region code for the country (or region) this building is in.
    pub region_code: std::string::String,

    /// Solar potential of the building.
    pub solar_potential: std::option::Option<crate::model::SolarPotential>,

    /// The quality of the imagery used to compute the data for this building.
    pub imagery_quality: crate::model::ImageryQuality,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BuildingInsights {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::BuildingInsights::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// let x = BuildingInsights::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [center][crate::model::BuildingInsights::center].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// use google_cloud_type::model::LatLng;
    /// let x = BuildingInsights::new().set_center(LatLng::default()/* use setters */);
    /// ```
    pub fn set_center<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.center = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [center][crate::model::BuildingInsights::center].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// use google_cloud_type::model::LatLng;
    /// let x = BuildingInsights::new().set_or_clear_center(Some(LatLng::default()/* use setters */));
    /// let x = BuildingInsights::new().set_or_clear_center(None::<LatLng>);
    /// ```
    pub fn set_or_clear_center<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.center = v.map(|x| x.into());
        self
    }

    /// Sets the value of [bounding_box][crate::model::BuildingInsights::bounding_box].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// use google_maps_solar_v1::model::LatLngBox;
    /// let x = BuildingInsights::new().set_bounding_box(LatLngBox::default()/* use setters */);
    /// ```
    pub fn set_bounding_box<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LatLngBox>,
    {
        self.bounding_box = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [bounding_box][crate::model::BuildingInsights::bounding_box].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// use google_maps_solar_v1::model::LatLngBox;
    /// let x = BuildingInsights::new().set_or_clear_bounding_box(Some(LatLngBox::default()/* use setters */));
    /// let x = BuildingInsights::new().set_or_clear_bounding_box(None::<LatLngBox>);
    /// ```
    pub fn set_or_clear_bounding_box<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::LatLngBox>,
    {
        self.bounding_box = v.map(|x| x.into());
        self
    }

    /// Sets the value of [imagery_date][crate::model::BuildingInsights::imagery_date].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// use google_cloud_type::model::Date;
    /// let x = BuildingInsights::new().set_imagery_date(Date::default()/* use setters */);
    /// ```
    pub fn set_imagery_date<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Date>,
    {
        self.imagery_date = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [imagery_date][crate::model::BuildingInsights::imagery_date].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// use google_cloud_type::model::Date;
    /// let x = BuildingInsights::new().set_or_clear_imagery_date(Some(Date::default()/* use setters */));
    /// let x = BuildingInsights::new().set_or_clear_imagery_date(None::<Date>);
    /// ```
    pub fn set_or_clear_imagery_date<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Date>,
    {
        self.imagery_date = v.map(|x| x.into());
        self
    }

    /// Sets the value of [imagery_processed_date][crate::model::BuildingInsights::imagery_processed_date].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// use google_cloud_type::model::Date;
    /// let x = BuildingInsights::new().set_imagery_processed_date(Date::default()/* use setters */);
    /// ```
    pub fn set_imagery_processed_date<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Date>,
    {
        self.imagery_processed_date = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [imagery_processed_date][crate::model::BuildingInsights::imagery_processed_date].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// use google_cloud_type::model::Date;
    /// let x = BuildingInsights::new().set_or_clear_imagery_processed_date(Some(Date::default()/* use setters */));
    /// let x = BuildingInsights::new().set_or_clear_imagery_processed_date(None::<Date>);
    /// ```
    pub fn set_or_clear_imagery_processed_date<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Date>,
    {
        self.imagery_processed_date = v.map(|x| x.into());
        self
    }

    /// Sets the value of [postal_code][crate::model::BuildingInsights::postal_code].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// let x = BuildingInsights::new().set_postal_code("example");
    /// ```
    pub fn set_postal_code<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.postal_code = v.into();
        self
    }

    /// Sets the value of [administrative_area][crate::model::BuildingInsights::administrative_area].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// let x = BuildingInsights::new().set_administrative_area("example");
    /// ```
    pub fn set_administrative_area<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.administrative_area = v.into();
        self
    }

    /// Sets the value of [statistical_area][crate::model::BuildingInsights::statistical_area].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// let x = BuildingInsights::new().set_statistical_area("example");
    /// ```
    pub fn set_statistical_area<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.statistical_area = v.into();
        self
    }

    /// Sets the value of [region_code][crate::model::BuildingInsights::region_code].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// let x = BuildingInsights::new().set_region_code("example");
    /// ```
    pub fn set_region_code<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.region_code = v.into();
        self
    }

    /// Sets the value of [solar_potential][crate::model::BuildingInsights::solar_potential].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// use google_maps_solar_v1::model::SolarPotential;
    /// let x = BuildingInsights::new().set_solar_potential(SolarPotential::default()/* use setters */);
    /// ```
    pub fn set_solar_potential<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SolarPotential>,
    {
        self.solar_potential = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [solar_potential][crate::model::BuildingInsights::solar_potential].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// use google_maps_solar_v1::model::SolarPotential;
    /// let x = BuildingInsights::new().set_or_clear_solar_potential(Some(SolarPotential::default()/* use setters */));
    /// let x = BuildingInsights::new().set_or_clear_solar_potential(None::<SolarPotential>);
    /// ```
    pub fn set_or_clear_solar_potential<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SolarPotential>,
    {
        self.solar_potential = v.map(|x| x.into());
        self
    }

    /// Sets the value of [imagery_quality][crate::model::BuildingInsights::imagery_quality].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::BuildingInsights;
    /// use google_maps_solar_v1::model::ImageryQuality;
    /// let x0 = BuildingInsights::new().set_imagery_quality(ImageryQuality::High);
    /// let x1 = BuildingInsights::new().set_imagery_quality(ImageryQuality::Medium);
    /// let x2 = BuildingInsights::new().set_imagery_quality(ImageryQuality::Low);
    /// ```
    pub fn set_imagery_quality<T: std::convert::Into<crate::model::ImageryQuality>>(
        mut self,
        v: T,
    ) -> Self {
        self.imagery_quality = v.into();
        self
    }
}

impl wkt::message::Message for BuildingInsights {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.BuildingInsights"
    }
}

/// Information about the solar potential of a building. A number of
/// fields in this are defined in terms of "panels". The fields
/// [panel_capacity_watts]
/// [google.maps.solar.v1.SolarPotential.panel_capacity_watts],
/// [panel_height_meters]
/// [google.maps.solar.v1.SolarPotential.panel_height_meters],
/// and [panel_width_meters]
/// [google.maps.solar.v1.SolarPotential.panel_width_meters]
/// describe the parameters of the model of panel used in these
/// calculations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SolarPotential {
    /// Size of the maximum array - that is, the maximum number of panels that
    /// can fit on the roof.
    pub max_array_panels_count: i32,

    /// Capacity, in watts, of the panel used in the calculations.
    pub panel_capacity_watts: f32,

    /// Height, in meters in portrait orientation, of the panel used in
    /// the calculations.
    pub panel_height_meters: f32,

    /// Width, in meters in portrait orientation, of the panel used in
    /// the calculations.
    pub panel_width_meters: f32,

    /// The expected lifetime, in years, of the solar panels. This is
    /// used in the financial calculations.
    pub panel_lifetime_years: i32,

    /// Size, in square meters, of the maximum array.
    pub max_array_area_meters2: f32,

    /// Maximum number of sunshine hours received per year, by any point
    /// on the roof. Sunshine hours are a measure of the total amount of
    /// insolation (energy) received per year. 1 sunshine hour = 1 kWh per kW
    /// (where kW refers to kW of capacity under Standard Testing Conditions).
    pub max_sunshine_hours_per_year: f32,

    /// Equivalent amount of CO2 produced per MWh of grid electricity. This
    /// is a measure of the carbon intensity of grid electricity displaced
    /// by solar electricity.
    pub carbon_offset_factor_kg_per_mwh: f32,

    /// Total size and sunlight quantiles for the part of the roof that
    /// was assigned to some roof segment. Despite the name, this may not
    /// include the entire building. See [building_stats]
    /// [google.maps.solar.v1.SolarPotential.building_stats].
    pub whole_roof_stats: std::option::Option<crate::model::SizeAndSunshineStats>,

    /// Size and sunlight quantiles for the entire building, including
    /// parts of the roof that were not assigned to some roof segment.
    /// Because the orientations of these parts are not well
    /// characterised, the roof area estimate is unreliable, but the
    /// ground area estimate is reliable. It may be that a more reliable
    /// whole building roof area can be obtained by scaling the roof area
    /// from [whole_roof_stats]
    /// [google.maps.solar.v1.SolarPotential.whole_roof_stats] by
    /// the ratio of the ground areas of `building_stats` and
    /// `whole_roof_stats`.
    pub building_stats: std::option::Option<crate::model::SizeAndSunshineStats>,

    /// Size and sunlight quantiles for each roof segment.
    pub roof_segment_stats: std::vec::Vec<crate::model::RoofSegmentSizeAndSunshineStats>,

    /// Each [SolarPanel] [google.maps.solar.v1.SolarPanel]
    /// describes a single solar panel. They are listed in the order that
    /// the panel layout algorithm placed this. This is usually, though
    /// not always, in decreasing order of annual energy production.
    pub solar_panels: std::vec::Vec<crate::model::SolarPanel>,

    /// Each [SolarPanelConfig]
    /// [google.maps.solar.v1.SolarPanelConfig] describes a
    /// different arrangement of solar panels on the roof. They are in
    /// order of increasing number of panels. The `SolarPanelConfig` with
    /// [panels_count]
    /// [google.maps.solar.v1.SolarPanelConfig.panels_count]=N is
    /// based on the first N panels in the `solar_panels` list. This field is only
    /// populated if at least 4 panels can fit on a roof.
    pub solar_panel_configs: std::vec::Vec<crate::model::SolarPanelConfig>,

    /// A [FinancialAnalysis]
    /// [google.maps.solar.v1.FinancialAnalysis] gives the savings
    /// from going solar assuming a given monthly bill and a given
    /// electricity provider. They are in order of increasing order of
    /// monthly bill amount. This field will be empty for buildings in
    /// areas for which the Solar API does not have enough information to
    /// perform financial computations.
    pub financial_analyses: std::vec::Vec<crate::model::FinancialAnalysis>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SolarPotential {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [max_array_panels_count][crate::model::SolarPotential::max_array_panels_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// let x = SolarPotential::new().set_max_array_panels_count(42);
    /// ```
    pub fn set_max_array_panels_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.max_array_panels_count = v.into();
        self
    }

    /// Sets the value of [panel_capacity_watts][crate::model::SolarPotential::panel_capacity_watts].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// let x = SolarPotential::new().set_panel_capacity_watts(42.0);
    /// ```
    pub fn set_panel_capacity_watts<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.panel_capacity_watts = v.into();
        self
    }

    /// Sets the value of [panel_height_meters][crate::model::SolarPotential::panel_height_meters].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// let x = SolarPotential::new().set_panel_height_meters(42.0);
    /// ```
    pub fn set_panel_height_meters<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.panel_height_meters = v.into();
        self
    }

    /// Sets the value of [panel_width_meters][crate::model::SolarPotential::panel_width_meters].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// let x = SolarPotential::new().set_panel_width_meters(42.0);
    /// ```
    pub fn set_panel_width_meters<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.panel_width_meters = v.into();
        self
    }

    /// Sets the value of [panel_lifetime_years][crate::model::SolarPotential::panel_lifetime_years].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// let x = SolarPotential::new().set_panel_lifetime_years(42);
    /// ```
    pub fn set_panel_lifetime_years<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.panel_lifetime_years = v.into();
        self
    }

    /// Sets the value of [max_array_area_meters2][crate::model::SolarPotential::max_array_area_meters2].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// let x = SolarPotential::new().set_max_array_area_meters2(42.0);
    /// ```
    pub fn set_max_array_area_meters2<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.max_array_area_meters2 = v.into();
        self
    }

    /// Sets the value of [max_sunshine_hours_per_year][crate::model::SolarPotential::max_sunshine_hours_per_year].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// let x = SolarPotential::new().set_max_sunshine_hours_per_year(42.0);
    /// ```
    pub fn set_max_sunshine_hours_per_year<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.max_sunshine_hours_per_year = v.into();
        self
    }

    /// Sets the value of [carbon_offset_factor_kg_per_mwh][crate::model::SolarPotential::carbon_offset_factor_kg_per_mwh].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// let x = SolarPotential::new().set_carbon_offset_factor_kg_per_mwh(42.0);
    /// ```
    pub fn set_carbon_offset_factor_kg_per_mwh<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.carbon_offset_factor_kg_per_mwh = v.into();
        self
    }

    /// Sets the value of [whole_roof_stats][crate::model::SolarPotential::whole_roof_stats].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// use google_maps_solar_v1::model::SizeAndSunshineStats;
    /// let x = SolarPotential::new().set_whole_roof_stats(SizeAndSunshineStats::default()/* use setters */);
    /// ```
    pub fn set_whole_roof_stats<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SizeAndSunshineStats>,
    {
        self.whole_roof_stats = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [whole_roof_stats][crate::model::SolarPotential::whole_roof_stats].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// use google_maps_solar_v1::model::SizeAndSunshineStats;
    /// let x = SolarPotential::new().set_or_clear_whole_roof_stats(Some(SizeAndSunshineStats::default()/* use setters */));
    /// let x = SolarPotential::new().set_or_clear_whole_roof_stats(None::<SizeAndSunshineStats>);
    /// ```
    pub fn set_or_clear_whole_roof_stats<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SizeAndSunshineStats>,
    {
        self.whole_roof_stats = v.map(|x| x.into());
        self
    }

    /// Sets the value of [building_stats][crate::model::SolarPotential::building_stats].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// use google_maps_solar_v1::model::SizeAndSunshineStats;
    /// let x = SolarPotential::new().set_building_stats(SizeAndSunshineStats::default()/* use setters */);
    /// ```
    pub fn set_building_stats<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SizeAndSunshineStats>,
    {
        self.building_stats = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [building_stats][crate::model::SolarPotential::building_stats].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// use google_maps_solar_v1::model::SizeAndSunshineStats;
    /// let x = SolarPotential::new().set_or_clear_building_stats(Some(SizeAndSunshineStats::default()/* use setters */));
    /// let x = SolarPotential::new().set_or_clear_building_stats(None::<SizeAndSunshineStats>);
    /// ```
    pub fn set_or_clear_building_stats<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SizeAndSunshineStats>,
    {
        self.building_stats = v.map(|x| x.into());
        self
    }

    /// Sets the value of [roof_segment_stats][crate::model::SolarPotential::roof_segment_stats].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// use google_maps_solar_v1::model::RoofSegmentSizeAndSunshineStats;
    /// let x = SolarPotential::new()
    ///     .set_roof_segment_stats([
    ///         RoofSegmentSizeAndSunshineStats::default()/* use setters */,
    ///         RoofSegmentSizeAndSunshineStats::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_roof_segment_stats<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::RoofSegmentSizeAndSunshineStats>,
    {
        use std::iter::Iterator;
        self.roof_segment_stats = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [solar_panels][crate::model::SolarPotential::solar_panels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// use google_maps_solar_v1::model::SolarPanel;
    /// let x = SolarPotential::new()
    ///     .set_solar_panels([
    ///         SolarPanel::default()/* use setters */,
    ///         SolarPanel::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_solar_panels<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::SolarPanel>,
    {
        use std::iter::Iterator;
        self.solar_panels = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [solar_panel_configs][crate::model::SolarPotential::solar_panel_configs].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// use google_maps_solar_v1::model::SolarPanelConfig;
    /// let x = SolarPotential::new()
    ///     .set_solar_panel_configs([
    ///         SolarPanelConfig::default()/* use setters */,
    ///         SolarPanelConfig::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_solar_panel_configs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::SolarPanelConfig>,
    {
        use std::iter::Iterator;
        self.solar_panel_configs = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [financial_analyses][crate::model::SolarPotential::financial_analyses].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPotential;
    /// use google_maps_solar_v1::model::FinancialAnalysis;
    /// let x = SolarPotential::new()
    ///     .set_financial_analyses([
    ///         FinancialAnalysis::default()/* use setters */,
    ///         FinancialAnalysis::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_financial_analyses<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::FinancialAnalysis>,
    {
        use std::iter::Iterator;
        self.financial_analyses = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for SolarPotential {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.SolarPotential"
    }
}

/// Information about the size and sunniness quantiles of a roof segment.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RoofSegmentSizeAndSunshineStats {
    /// Angle of the roof segment relative to the theoretical ground plane.
    /// 0 = parallel to the ground, 90 = perpendicular to the ground.
    pub pitch_degrees: std::option::Option<f32>,

    /// Compass direction the roof segment is pointing in. 0 = North, 90 =
    /// East, 180 = South. For a "flat" roof segment (`pitch_degrees` very
    /// near 0), azimuth is not well defined, so for consistency, we define it
    /// arbitrarily to be 0 (North).
    pub azimuth_degrees: std::option::Option<f32>,

    /// Total size and sunlight quantiles for the roof segment.
    pub stats: std::option::Option<crate::model::SizeAndSunshineStats>,

    /// A point near the center of the roof segment.
    pub center: std::option::Option<google_cloud_type::model::LatLng>,

    /// The bounding box of the roof segment.
    pub bounding_box: std::option::Option<crate::model::LatLngBox>,

    /// The height of the roof segment plane, in meters above sea level,
    /// at the point designated by `center`. Together with the pitch,
    /// azimuth, and center location, this fully defines the roof segment
    /// plane.
    pub plane_height_at_center_meters: std::option::Option<f32>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl RoofSegmentSizeAndSunshineStats {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [pitch_degrees][crate::model::RoofSegmentSizeAndSunshineStats::pitch_degrees].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSizeAndSunshineStats;
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_pitch_degrees(42.0);
    /// ```
    pub fn set_pitch_degrees<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.pitch_degrees = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [pitch_degrees][crate::model::RoofSegmentSizeAndSunshineStats::pitch_degrees].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSizeAndSunshineStats;
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_or_clear_pitch_degrees(Some(42.0));
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_or_clear_pitch_degrees(None::<f32>);
    /// ```
    pub fn set_or_clear_pitch_degrees<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.pitch_degrees = v.map(|x| x.into());
        self
    }

    /// Sets the value of [azimuth_degrees][crate::model::RoofSegmentSizeAndSunshineStats::azimuth_degrees].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSizeAndSunshineStats;
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_azimuth_degrees(42.0);
    /// ```
    pub fn set_azimuth_degrees<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.azimuth_degrees = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [azimuth_degrees][crate::model::RoofSegmentSizeAndSunshineStats::azimuth_degrees].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSizeAndSunshineStats;
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_or_clear_azimuth_degrees(Some(42.0));
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_or_clear_azimuth_degrees(None::<f32>);
    /// ```
    pub fn set_or_clear_azimuth_degrees<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.azimuth_degrees = v.map(|x| x.into());
        self
    }

    /// Sets the value of [stats][crate::model::RoofSegmentSizeAndSunshineStats::stats].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSizeAndSunshineStats;
    /// use google_maps_solar_v1::model::SizeAndSunshineStats;
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_stats(SizeAndSunshineStats::default()/* use setters */);
    /// ```
    pub fn set_stats<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SizeAndSunshineStats>,
    {
        self.stats = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [stats][crate::model::RoofSegmentSizeAndSunshineStats::stats].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSizeAndSunshineStats;
    /// use google_maps_solar_v1::model::SizeAndSunshineStats;
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_or_clear_stats(Some(SizeAndSunshineStats::default()/* use setters */));
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_or_clear_stats(None::<SizeAndSunshineStats>);
    /// ```
    pub fn set_or_clear_stats<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SizeAndSunshineStats>,
    {
        self.stats = v.map(|x| x.into());
        self
    }

    /// Sets the value of [center][crate::model::RoofSegmentSizeAndSunshineStats::center].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSizeAndSunshineStats;
    /// use google_cloud_type::model::LatLng;
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_center(LatLng::default()/* use setters */);
    /// ```
    pub fn set_center<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.center = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [center][crate::model::RoofSegmentSizeAndSunshineStats::center].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSizeAndSunshineStats;
    /// use google_cloud_type::model::LatLng;
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_or_clear_center(Some(LatLng::default()/* use setters */));
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_or_clear_center(None::<LatLng>);
    /// ```
    pub fn set_or_clear_center<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.center = v.map(|x| x.into());
        self
    }

    /// Sets the value of [bounding_box][crate::model::RoofSegmentSizeAndSunshineStats::bounding_box].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSizeAndSunshineStats;
    /// use google_maps_solar_v1::model::LatLngBox;
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_bounding_box(LatLngBox::default()/* use setters */);
    /// ```
    pub fn set_bounding_box<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LatLngBox>,
    {
        self.bounding_box = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [bounding_box][crate::model::RoofSegmentSizeAndSunshineStats::bounding_box].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSizeAndSunshineStats;
    /// use google_maps_solar_v1::model::LatLngBox;
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_or_clear_bounding_box(Some(LatLngBox::default()/* use setters */));
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_or_clear_bounding_box(None::<LatLngBox>);
    /// ```
    pub fn set_or_clear_bounding_box<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::LatLngBox>,
    {
        self.bounding_box = v.map(|x| x.into());
        self
    }

    /// Sets the value of [plane_height_at_center_meters][crate::model::RoofSegmentSizeAndSunshineStats::plane_height_at_center_meters].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSizeAndSunshineStats;
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_plane_height_at_center_meters(42.0);
    /// ```
    pub fn set_plane_height_at_center_meters<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.plane_height_at_center_meters = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [plane_height_at_center_meters][crate::model::RoofSegmentSizeAndSunshineStats::plane_height_at_center_meters].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSizeAndSunshineStats;
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_or_clear_plane_height_at_center_meters(Some(42.0));
    /// let x = RoofSegmentSizeAndSunshineStats::new().set_or_clear_plane_height_at_center_meters(None::<f32>);
    /// ```
    pub fn set_or_clear_plane_height_at_center_meters<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.plane_height_at_center_meters = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for RoofSegmentSizeAndSunshineStats {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.RoofSegmentSizeAndSunshineStats"
    }
}

/// Size and sunniness quantiles of a roof, or part of a roof.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SizeAndSunshineStats {
    /// The area of the roof or roof segment, in m^2. This is the roof area
    /// (accounting for tilt), not the ground footprint area.
    pub area_meters2: f32,

    /// Quantiles of the pointwise sunniness across the area. If there
    /// are N values here, this represents the (N-1)-iles. For example,
    /// if there are 5 values, then they would be the quartiles (min,
    /// 25%, 50%, 75%, max). Values are in annual kWh/kW like
    /// [max_sunshine_hours_per_year]
    /// [google.maps.solar.v1.SolarPotential.max_sunshine_hours_per_year].
    pub sunshine_quantiles: std::vec::Vec<f32>,

    /// The ground footprint area covered by the roof or roof segment, in m^2.
    pub ground_area_meters2: f32,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SizeAndSunshineStats {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [area_meters2][crate::model::SizeAndSunshineStats::area_meters2].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SizeAndSunshineStats;
    /// let x = SizeAndSunshineStats::new().set_area_meters2(42.0);
    /// ```
    pub fn set_area_meters2<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.area_meters2 = v.into();
        self
    }

    /// Sets the value of [sunshine_quantiles][crate::model::SizeAndSunshineStats::sunshine_quantiles].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SizeAndSunshineStats;
    /// let x = SizeAndSunshineStats::new().set_sunshine_quantiles([1.0, 2.0, 3.0]);
    /// ```
    pub fn set_sunshine_quantiles<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<f32>,
    {
        use std::iter::Iterator;
        self.sunshine_quantiles = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [ground_area_meters2][crate::model::SizeAndSunshineStats::ground_area_meters2].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SizeAndSunshineStats;
    /// let x = SizeAndSunshineStats::new().set_ground_area_meters2(42.0);
    /// ```
    pub fn set_ground_area_meters2<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.ground_area_meters2 = v.into();
        self
    }
}

impl wkt::message::Message for SizeAndSunshineStats {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.SizeAndSunshineStats"
    }
}

/// SolarPanel describes the position, orientation, and production of a
/// single solar panel. See the [panel_height_meters]
/// [google.maps.solar.v1.SolarPotential.panel_height_meters],
/// [panel_width_meters]
/// [google.maps.solar.v1.SolarPotential.panel_width_meters],
/// and [panel_capacity_watts]
/// [google.maps.solar.v1.SolarPotential.panel_capacity_watts]
/// fields in [SolarPotential]
/// [google.maps.solar.v1.SolarPotential] for information on the
/// parameters of the panel.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SolarPanel {
    /// The centre of the panel.
    pub center: std::option::Option<google_cloud_type::model::LatLng>,

    /// The orientation of the panel.
    pub orientation: crate::model::SolarPanelOrientation,

    /// How much sunlight energy this layout captures over the course of a
    /// year, in DC kWh.
    pub yearly_energy_dc_kwh: f32,

    /// Index in [roof_segment_stats]
    /// [google.maps.solar.v1.SolarPotential.roof_segment_stats]
    /// of the `RoofSegmentSizeAndSunshineStats` which corresponds to the
    /// roof segment that this panel is placed on.
    pub segment_index: std::option::Option<i32>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SolarPanel {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [center][crate::model::SolarPanel::center].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPanel;
    /// use google_cloud_type::model::LatLng;
    /// let x = SolarPanel::new().set_center(LatLng::default()/* use setters */);
    /// ```
    pub fn set_center<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.center = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [center][crate::model::SolarPanel::center].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPanel;
    /// use google_cloud_type::model::LatLng;
    /// let x = SolarPanel::new().set_or_clear_center(Some(LatLng::default()/* use setters */));
    /// let x = SolarPanel::new().set_or_clear_center(None::<LatLng>);
    /// ```
    pub fn set_or_clear_center<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.center = v.map(|x| x.into());
        self
    }

    /// Sets the value of [orientation][crate::model::SolarPanel::orientation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPanel;
    /// use google_maps_solar_v1::model::SolarPanelOrientation;
    /// let x0 = SolarPanel::new().set_orientation(SolarPanelOrientation::Landscape);
    /// let x1 = SolarPanel::new().set_orientation(SolarPanelOrientation::Portrait);
    /// ```
    pub fn set_orientation<T: std::convert::Into<crate::model::SolarPanelOrientation>>(
        mut self,
        v: T,
    ) -> Self {
        self.orientation = v.into();
        self
    }

    /// Sets the value of [yearly_energy_dc_kwh][crate::model::SolarPanel::yearly_energy_dc_kwh].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPanel;
    /// let x = SolarPanel::new().set_yearly_energy_dc_kwh(42.0);
    /// ```
    pub fn set_yearly_energy_dc_kwh<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.yearly_energy_dc_kwh = v.into();
        self
    }

    /// Sets the value of [segment_index][crate::model::SolarPanel::segment_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPanel;
    /// let x = SolarPanel::new().set_segment_index(42);
    /// ```
    pub fn set_segment_index<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.segment_index = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [segment_index][crate::model::SolarPanel::segment_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPanel;
    /// let x = SolarPanel::new().set_or_clear_segment_index(Some(42));
    /// let x = SolarPanel::new().set_or_clear_segment_index(None::<i32>);
    /// ```
    pub fn set_or_clear_segment_index<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.segment_index = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for SolarPanel {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.SolarPanel"
    }
}

/// SolarPanelConfig describes a particular placement of solar panels
/// on the roof.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SolarPanelConfig {
    /// Total number of panels. Note that this is redundant to (the sum
    /// of) the corresponding fields in [roof_segment_summaries]
    /// [google.maps.solar.v1.SolarPanelConfig.roof_segment_summaries].
    pub panels_count: i32,

    /// How much sunlight energy this layout captures over the course of a
    /// year, in DC kWh, assuming the panels described above.
    pub yearly_energy_dc_kwh: f32,

    /// Information about the production of each roof segment that is carrying
    /// at least one panel in this layout. `roof_segment_summaries[i]` describes
    /// the i-th roof segment, including its size, expected production and
    /// orientation.
    pub roof_segment_summaries: std::vec::Vec<crate::model::RoofSegmentSummary>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SolarPanelConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [panels_count][crate::model::SolarPanelConfig::panels_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPanelConfig;
    /// let x = SolarPanelConfig::new().set_panels_count(42);
    /// ```
    pub fn set_panels_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.panels_count = v.into();
        self
    }

    /// Sets the value of [yearly_energy_dc_kwh][crate::model::SolarPanelConfig::yearly_energy_dc_kwh].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPanelConfig;
    /// let x = SolarPanelConfig::new().set_yearly_energy_dc_kwh(42.0);
    /// ```
    pub fn set_yearly_energy_dc_kwh<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.yearly_energy_dc_kwh = v.into();
        self
    }

    /// Sets the value of [roof_segment_summaries][crate::model::SolarPanelConfig::roof_segment_summaries].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SolarPanelConfig;
    /// use google_maps_solar_v1::model::RoofSegmentSummary;
    /// let x = SolarPanelConfig::new()
    ///     .set_roof_segment_summaries([
    ///         RoofSegmentSummary::default()/* use setters */,
    ///         RoofSegmentSummary::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_roof_segment_summaries<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::RoofSegmentSummary>,
    {
        use std::iter::Iterator;
        self.roof_segment_summaries = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for SolarPanelConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.SolarPanelConfig"
    }
}

/// Information about a roof segment on the building, with some number of
/// panels placed on it.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RoofSegmentSummary {
    /// Angle of the roof segment relative to the theoretical ground plane.
    /// 0 = parallel to the ground, 90 = perpendicular to the ground.
    pub pitch_degrees: std::option::Option<f32>,

    /// Compass direction the roof segment is pointing in. 0 = North, 90 =
    /// East, 180 = South. For a "flat" roof segment (`pitch_degrees` very
    /// near 0), azimuth is not well defined, so for consistency, we define it
    /// arbitrarily to be 0 (North).
    pub azimuth_degrees: std::option::Option<f32>,

    /// The total number of panels on this segment.
    pub panels_count: i32,

    /// How much sunlight energy this part of the layout captures over the
    /// course of a year, in DC kWh, assuming the panels described above.
    pub yearly_energy_dc_kwh: f32,

    /// Index in [roof_segment_stats]
    /// [google.maps.solar.v1.SolarPotential.roof_segment_stats]
    /// of the corresponding `RoofSegmentSizeAndSunshineStats`.
    pub segment_index: std::option::Option<i32>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl RoofSegmentSummary {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [pitch_degrees][crate::model::RoofSegmentSummary::pitch_degrees].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSummary;
    /// let x = RoofSegmentSummary::new().set_pitch_degrees(42.0);
    /// ```
    pub fn set_pitch_degrees<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.pitch_degrees = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [pitch_degrees][crate::model::RoofSegmentSummary::pitch_degrees].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSummary;
    /// let x = RoofSegmentSummary::new().set_or_clear_pitch_degrees(Some(42.0));
    /// let x = RoofSegmentSummary::new().set_or_clear_pitch_degrees(None::<f32>);
    /// ```
    pub fn set_or_clear_pitch_degrees<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.pitch_degrees = v.map(|x| x.into());
        self
    }

    /// Sets the value of [azimuth_degrees][crate::model::RoofSegmentSummary::azimuth_degrees].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSummary;
    /// let x = RoofSegmentSummary::new().set_azimuth_degrees(42.0);
    /// ```
    pub fn set_azimuth_degrees<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.azimuth_degrees = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [azimuth_degrees][crate::model::RoofSegmentSummary::azimuth_degrees].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSummary;
    /// let x = RoofSegmentSummary::new().set_or_clear_azimuth_degrees(Some(42.0));
    /// let x = RoofSegmentSummary::new().set_or_clear_azimuth_degrees(None::<f32>);
    /// ```
    pub fn set_or_clear_azimuth_degrees<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.azimuth_degrees = v.map(|x| x.into());
        self
    }

    /// Sets the value of [panels_count][crate::model::RoofSegmentSummary::panels_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSummary;
    /// let x = RoofSegmentSummary::new().set_panels_count(42);
    /// ```
    pub fn set_panels_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.panels_count = v.into();
        self
    }

    /// Sets the value of [yearly_energy_dc_kwh][crate::model::RoofSegmentSummary::yearly_energy_dc_kwh].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSummary;
    /// let x = RoofSegmentSummary::new().set_yearly_energy_dc_kwh(42.0);
    /// ```
    pub fn set_yearly_energy_dc_kwh<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.yearly_energy_dc_kwh = v.into();
        self
    }

    /// Sets the value of [segment_index][crate::model::RoofSegmentSummary::segment_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSummary;
    /// let x = RoofSegmentSummary::new().set_segment_index(42);
    /// ```
    pub fn set_segment_index<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.segment_index = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [segment_index][crate::model::RoofSegmentSummary::segment_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::RoofSegmentSummary;
    /// let x = RoofSegmentSummary::new().set_or_clear_segment_index(Some(42));
    /// let x = RoofSegmentSummary::new().set_or_clear_segment_index(None::<i32>);
    /// ```
    pub fn set_or_clear_segment_index<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.segment_index = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for RoofSegmentSummary {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.RoofSegmentSummary"
    }
}

/// Analysis of the cost and benefits of the optimum solar layout for a
/// particular electric bill size.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FinancialAnalysis {
    /// The monthly electric bill this analysis assumes.
    pub monthly_bill: std::option::Option<google_cloud_type::model::Money>,

    /// Whether this is the bill size selected to be the default bill for the
    /// area this building is in. Exactly one `FinancialAnalysis` in
    /// `BuildingSolarPotential` should have `default_bill` set.
    pub default_bill: bool,

    /// How much electricity the house uses in an average month, based on the
    /// bill size and the local electricity rates.
    pub average_kwh_per_month: f32,

    /// Index in [solar_panel_configs]
    /// [google.maps.solar.v1.SolarPotential.solar_panel_configs]
    /// of the optimum solar layout for this bill size. This can be -1
    /// indicating that there is no layout. In this case, the remaining
    /// submessages will be omitted.
    pub panel_config_index: std::option::Option<i32>,

    /// Financial information that applies regardless of the financing method
    /// used.
    pub financial_details: std::option::Option<crate::model::FinancialDetails>,

    /// Cost and benefit of leasing the solar panels.
    pub leasing_savings: std::option::Option<crate::model::LeasingSavings>,

    /// Cost and benefit of buying the solar panels with cash.
    pub cash_purchase_savings: std::option::Option<crate::model::CashPurchaseSavings>,

    /// Cost and benefit of buying the solar panels by financing the purchase.
    pub financed_purchase_savings: std::option::Option<crate::model::FinancedPurchaseSavings>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FinancialAnalysis {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [monthly_bill][crate::model::FinancialAnalysis::monthly_bill].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialAnalysis::new().set_monthly_bill(Money::default()/* use setters */);
    /// ```
    pub fn set_monthly_bill<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.monthly_bill = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [monthly_bill][crate::model::FinancialAnalysis::monthly_bill].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialAnalysis::new().set_or_clear_monthly_bill(Some(Money::default()/* use setters */));
    /// let x = FinancialAnalysis::new().set_or_clear_monthly_bill(None::<Money>);
    /// ```
    pub fn set_or_clear_monthly_bill<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.monthly_bill = v.map(|x| x.into());
        self
    }

    /// Sets the value of [default_bill][crate::model::FinancialAnalysis::default_bill].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// let x = FinancialAnalysis::new().set_default_bill(true);
    /// ```
    pub fn set_default_bill<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.default_bill = v.into();
        self
    }

    /// Sets the value of [average_kwh_per_month][crate::model::FinancialAnalysis::average_kwh_per_month].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// let x = FinancialAnalysis::new().set_average_kwh_per_month(42.0);
    /// ```
    pub fn set_average_kwh_per_month<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.average_kwh_per_month = v.into();
        self
    }

    /// Sets the value of [panel_config_index][crate::model::FinancialAnalysis::panel_config_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// let x = FinancialAnalysis::new().set_panel_config_index(42);
    /// ```
    pub fn set_panel_config_index<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.panel_config_index = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [panel_config_index][crate::model::FinancialAnalysis::panel_config_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// let x = FinancialAnalysis::new().set_or_clear_panel_config_index(Some(42));
    /// let x = FinancialAnalysis::new().set_or_clear_panel_config_index(None::<i32>);
    /// ```
    pub fn set_or_clear_panel_config_index<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.panel_config_index = v.map(|x| x.into());
        self
    }

    /// Sets the value of [financial_details][crate::model::FinancialAnalysis::financial_details].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// use google_maps_solar_v1::model::FinancialDetails;
    /// let x = FinancialAnalysis::new().set_financial_details(FinancialDetails::default()/* use setters */);
    /// ```
    pub fn set_financial_details<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::FinancialDetails>,
    {
        self.financial_details = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [financial_details][crate::model::FinancialAnalysis::financial_details].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// use google_maps_solar_v1::model::FinancialDetails;
    /// let x = FinancialAnalysis::new().set_or_clear_financial_details(Some(FinancialDetails::default()/* use setters */));
    /// let x = FinancialAnalysis::new().set_or_clear_financial_details(None::<FinancialDetails>);
    /// ```
    pub fn set_or_clear_financial_details<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::FinancialDetails>,
    {
        self.financial_details = v.map(|x| x.into());
        self
    }

    /// Sets the value of [leasing_savings][crate::model::FinancialAnalysis::leasing_savings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// use google_maps_solar_v1::model::LeasingSavings;
    /// let x = FinancialAnalysis::new().set_leasing_savings(LeasingSavings::default()/* use setters */);
    /// ```
    pub fn set_leasing_savings<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LeasingSavings>,
    {
        self.leasing_savings = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [leasing_savings][crate::model::FinancialAnalysis::leasing_savings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// use google_maps_solar_v1::model::LeasingSavings;
    /// let x = FinancialAnalysis::new().set_or_clear_leasing_savings(Some(LeasingSavings::default()/* use setters */));
    /// let x = FinancialAnalysis::new().set_or_clear_leasing_savings(None::<LeasingSavings>);
    /// ```
    pub fn set_or_clear_leasing_savings<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::LeasingSavings>,
    {
        self.leasing_savings = v.map(|x| x.into());
        self
    }

    /// Sets the value of [cash_purchase_savings][crate::model::FinancialAnalysis::cash_purchase_savings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// use google_maps_solar_v1::model::CashPurchaseSavings;
    /// let x = FinancialAnalysis::new().set_cash_purchase_savings(CashPurchaseSavings::default()/* use setters */);
    /// ```
    pub fn set_cash_purchase_savings<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::CashPurchaseSavings>,
    {
        self.cash_purchase_savings = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [cash_purchase_savings][crate::model::FinancialAnalysis::cash_purchase_savings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// use google_maps_solar_v1::model::CashPurchaseSavings;
    /// let x = FinancialAnalysis::new().set_or_clear_cash_purchase_savings(Some(CashPurchaseSavings::default()/* use setters */));
    /// let x = FinancialAnalysis::new().set_or_clear_cash_purchase_savings(None::<CashPurchaseSavings>);
    /// ```
    pub fn set_or_clear_cash_purchase_savings<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::CashPurchaseSavings>,
    {
        self.cash_purchase_savings = v.map(|x| x.into());
        self
    }

    /// Sets the value of [financed_purchase_savings][crate::model::FinancialAnalysis::financed_purchase_savings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// use google_maps_solar_v1::model::FinancedPurchaseSavings;
    /// let x = FinancialAnalysis::new().set_financed_purchase_savings(FinancedPurchaseSavings::default()/* use setters */);
    /// ```
    pub fn set_financed_purchase_savings<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::FinancedPurchaseSavings>,
    {
        self.financed_purchase_savings = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [financed_purchase_savings][crate::model::FinancialAnalysis::financed_purchase_savings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialAnalysis;
    /// use google_maps_solar_v1::model::FinancedPurchaseSavings;
    /// let x = FinancialAnalysis::new().set_or_clear_financed_purchase_savings(Some(FinancedPurchaseSavings::default()/* use setters */));
    /// let x = FinancialAnalysis::new().set_or_clear_financed_purchase_savings(None::<FinancedPurchaseSavings>);
    /// ```
    pub fn set_or_clear_financed_purchase_savings<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::FinancedPurchaseSavings>,
    {
        self.financed_purchase_savings = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for FinancialAnalysis {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.FinancialAnalysis"
    }
}

/// Details of a financial analysis. Some of these details are already
/// stored at higher levels (e.g., out of pocket cost). Total money
/// amounts are over a lifetime period defined by the
/// [panel_lifetime_years]
/// [google.maps.solar.v1.SolarPotential.panel_lifetime_years]
/// field in [SolarPotential]
/// [google.maps.solar.v1.SolarPotential]. Note: The out of
/// pocket cost of purchasing the panels is given in the
/// [out_of_pocket_cost]
/// [google.maps.solar.v1.CashPurchaseSavings.out_of_pocket_cost]
/// field in [CashPurchaseSavings]
/// [google.maps.solar.v1.CashPurchaseSavings].
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FinancialDetails {
    /// How many AC kWh we think the solar panels will generate in their first
    /// year.
    pub initial_ac_kwh_per_year: f32,

    /// Utility bill for electricity not produced by solar, for the
    /// lifetime of the panels.
    pub remaining_lifetime_utility_bill: std::option::Option<google_cloud_type::model::Money>,

    /// Amount of money available from federal incentives; this applies if the
    /// user buys (with or without a loan) the panels.
    pub federal_incentive: std::option::Option<google_cloud_type::model::Money>,

    /// Amount of money available from state incentives; this applies if the
    /// user buys (with or without a loan) the panels.
    pub state_incentive: std::option::Option<google_cloud_type::model::Money>,

    /// Amount of money available from utility incentives; this applies if the
    /// user buys (with or without a loan) the panels.
    pub utility_incentive: std::option::Option<google_cloud_type::model::Money>,

    /// Amount of money the user will receive from Solar Renewable Energy
    /// Credits over the panel lifetime; this applies if the user buys
    /// (with or without a loan) the panels.
    pub lifetime_srec_total: std::option::Option<google_cloud_type::model::Money>,

    /// Total cost of electricity the user would have paid over the
    /// lifetime period if they didn't install solar.
    pub cost_of_electricity_without_solar: std::option::Option<google_cloud_type::model::Money>,

    /// Whether net metering is allowed.
    pub net_metering_allowed: bool,

    /// Percentage (0-100) of the user's power supplied by solar.
    /// Valid for the first year but approximately correct for future years.
    pub solar_percentage: std::option::Option<f32>,

    /// The percentage (0-100) of solar electricity production we assumed was
    /// exported to the grid, based on the first quarter of production. This
    /// affects the calculations if net metering is not allowed.
    pub percentage_exported_to_grid: std::option::Option<f32>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FinancialDetails {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [initial_ac_kwh_per_year][crate::model::FinancialDetails::initial_ac_kwh_per_year].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// let x = FinancialDetails::new().set_initial_ac_kwh_per_year(42.0);
    /// ```
    pub fn set_initial_ac_kwh_per_year<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.initial_ac_kwh_per_year = v.into();
        self
    }

    /// Sets the value of [remaining_lifetime_utility_bill][crate::model::FinancialDetails::remaining_lifetime_utility_bill].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialDetails::new().set_remaining_lifetime_utility_bill(Money::default()/* use setters */);
    /// ```
    pub fn set_remaining_lifetime_utility_bill<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.remaining_lifetime_utility_bill = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [remaining_lifetime_utility_bill][crate::model::FinancialDetails::remaining_lifetime_utility_bill].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialDetails::new().set_or_clear_remaining_lifetime_utility_bill(Some(Money::default()/* use setters */));
    /// let x = FinancialDetails::new().set_or_clear_remaining_lifetime_utility_bill(None::<Money>);
    /// ```
    pub fn set_or_clear_remaining_lifetime_utility_bill<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.remaining_lifetime_utility_bill = v.map(|x| x.into());
        self
    }

    /// Sets the value of [federal_incentive][crate::model::FinancialDetails::federal_incentive].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialDetails::new().set_federal_incentive(Money::default()/* use setters */);
    /// ```
    pub fn set_federal_incentive<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.federal_incentive = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [federal_incentive][crate::model::FinancialDetails::federal_incentive].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialDetails::new().set_or_clear_federal_incentive(Some(Money::default()/* use setters */));
    /// let x = FinancialDetails::new().set_or_clear_federal_incentive(None::<Money>);
    /// ```
    pub fn set_or_clear_federal_incentive<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.federal_incentive = v.map(|x| x.into());
        self
    }

    /// Sets the value of [state_incentive][crate::model::FinancialDetails::state_incentive].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialDetails::new().set_state_incentive(Money::default()/* use setters */);
    /// ```
    pub fn set_state_incentive<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.state_incentive = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [state_incentive][crate::model::FinancialDetails::state_incentive].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialDetails::new().set_or_clear_state_incentive(Some(Money::default()/* use setters */));
    /// let x = FinancialDetails::new().set_or_clear_state_incentive(None::<Money>);
    /// ```
    pub fn set_or_clear_state_incentive<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.state_incentive = v.map(|x| x.into());
        self
    }

    /// Sets the value of [utility_incentive][crate::model::FinancialDetails::utility_incentive].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialDetails::new().set_utility_incentive(Money::default()/* use setters */);
    /// ```
    pub fn set_utility_incentive<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.utility_incentive = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [utility_incentive][crate::model::FinancialDetails::utility_incentive].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialDetails::new().set_or_clear_utility_incentive(Some(Money::default()/* use setters */));
    /// let x = FinancialDetails::new().set_or_clear_utility_incentive(None::<Money>);
    /// ```
    pub fn set_or_clear_utility_incentive<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.utility_incentive = v.map(|x| x.into());
        self
    }

    /// Sets the value of [lifetime_srec_total][crate::model::FinancialDetails::lifetime_srec_total].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialDetails::new().set_lifetime_srec_total(Money::default()/* use setters */);
    /// ```
    pub fn set_lifetime_srec_total<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.lifetime_srec_total = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [lifetime_srec_total][crate::model::FinancialDetails::lifetime_srec_total].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialDetails::new().set_or_clear_lifetime_srec_total(Some(Money::default()/* use setters */));
    /// let x = FinancialDetails::new().set_or_clear_lifetime_srec_total(None::<Money>);
    /// ```
    pub fn set_or_clear_lifetime_srec_total<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.lifetime_srec_total = v.map(|x| x.into());
        self
    }

    /// Sets the value of [cost_of_electricity_without_solar][crate::model::FinancialDetails::cost_of_electricity_without_solar].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialDetails::new().set_cost_of_electricity_without_solar(Money::default()/* use setters */);
    /// ```
    pub fn set_cost_of_electricity_without_solar<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.cost_of_electricity_without_solar = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [cost_of_electricity_without_solar][crate::model::FinancialDetails::cost_of_electricity_without_solar].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// use google_cloud_type::model::Money;
    /// let x = FinancialDetails::new().set_or_clear_cost_of_electricity_without_solar(Some(Money::default()/* use setters */));
    /// let x = FinancialDetails::new().set_or_clear_cost_of_electricity_without_solar(None::<Money>);
    /// ```
    pub fn set_or_clear_cost_of_electricity_without_solar<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.cost_of_electricity_without_solar = v.map(|x| x.into());
        self
    }

    /// Sets the value of [net_metering_allowed][crate::model::FinancialDetails::net_metering_allowed].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// let x = FinancialDetails::new().set_net_metering_allowed(true);
    /// ```
    pub fn set_net_metering_allowed<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.net_metering_allowed = v.into();
        self
    }

    /// Sets the value of [solar_percentage][crate::model::FinancialDetails::solar_percentage].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// let x = FinancialDetails::new().set_solar_percentage(42.0);
    /// ```
    pub fn set_solar_percentage<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.solar_percentage = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [solar_percentage][crate::model::FinancialDetails::solar_percentage].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// let x = FinancialDetails::new().set_or_clear_solar_percentage(Some(42.0));
    /// let x = FinancialDetails::new().set_or_clear_solar_percentage(None::<f32>);
    /// ```
    pub fn set_or_clear_solar_percentage<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.solar_percentage = v.map(|x| x.into());
        self
    }

    /// Sets the value of [percentage_exported_to_grid][crate::model::FinancialDetails::percentage_exported_to_grid].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// let x = FinancialDetails::new().set_percentage_exported_to_grid(42.0);
    /// ```
    pub fn set_percentage_exported_to_grid<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.percentage_exported_to_grid = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [percentage_exported_to_grid][crate::model::FinancialDetails::percentage_exported_to_grid].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancialDetails;
    /// let x = FinancialDetails::new().set_or_clear_percentage_exported_to_grid(Some(42.0));
    /// let x = FinancialDetails::new().set_or_clear_percentage_exported_to_grid(None::<f32>);
    /// ```
    pub fn set_or_clear_percentage_exported_to_grid<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.percentage_exported_to_grid = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for FinancialDetails {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.FinancialDetails"
    }
}

/// Financial information that's shared between different financing methods.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SavingsOverTime {
    /// Savings in the first year after panel installation.
    pub savings_year1: std::option::Option<google_cloud_type::model::Money>,

    /// Savings in the first twenty years after panel installation.
    pub savings_year20: std::option::Option<google_cloud_type::model::Money>,

    /// Using the assumed discount rate, what is the present value of the
    /// cumulative 20-year savings?
    pub present_value_of_savings_year20: std::option::Option<google_cloud_type::model::Money>,

    /// Savings in the entire panel lifetime.
    pub savings_lifetime: std::option::Option<google_cloud_type::model::Money>,

    /// Using the assumed discount rate, what is the present value of the
    /// cumulative lifetime savings?
    pub present_value_of_savings_lifetime: std::option::Option<google_cloud_type::model::Money>,

    /// Indicates whether this scenario is financially viable.  Will be false for
    /// scenarios with poor financial viability (e.g., money-losing).
    pub financially_viable: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SavingsOverTime {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [savings_year1][crate::model::SavingsOverTime::savings_year1].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SavingsOverTime;
    /// use google_cloud_type::model::Money;
    /// let x = SavingsOverTime::new().set_savings_year1(Money::default()/* use setters */);
    /// ```
    pub fn set_savings_year1<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.savings_year1 = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [savings_year1][crate::model::SavingsOverTime::savings_year1].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SavingsOverTime;
    /// use google_cloud_type::model::Money;
    /// let x = SavingsOverTime::new().set_or_clear_savings_year1(Some(Money::default()/* use setters */));
    /// let x = SavingsOverTime::new().set_or_clear_savings_year1(None::<Money>);
    /// ```
    pub fn set_or_clear_savings_year1<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.savings_year1 = v.map(|x| x.into());
        self
    }

    /// Sets the value of [savings_year20][crate::model::SavingsOverTime::savings_year20].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SavingsOverTime;
    /// use google_cloud_type::model::Money;
    /// let x = SavingsOverTime::new().set_savings_year20(Money::default()/* use setters */);
    /// ```
    pub fn set_savings_year20<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.savings_year20 = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [savings_year20][crate::model::SavingsOverTime::savings_year20].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SavingsOverTime;
    /// use google_cloud_type::model::Money;
    /// let x = SavingsOverTime::new().set_or_clear_savings_year20(Some(Money::default()/* use setters */));
    /// let x = SavingsOverTime::new().set_or_clear_savings_year20(None::<Money>);
    /// ```
    pub fn set_or_clear_savings_year20<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.savings_year20 = v.map(|x| x.into());
        self
    }

    /// Sets the value of [present_value_of_savings_year20][crate::model::SavingsOverTime::present_value_of_savings_year20].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SavingsOverTime;
    /// use google_cloud_type::model::Money;
    /// let x = SavingsOverTime::new().set_present_value_of_savings_year20(Money::default()/* use setters */);
    /// ```
    pub fn set_present_value_of_savings_year20<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.present_value_of_savings_year20 = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [present_value_of_savings_year20][crate::model::SavingsOverTime::present_value_of_savings_year20].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SavingsOverTime;
    /// use google_cloud_type::model::Money;
    /// let x = SavingsOverTime::new().set_or_clear_present_value_of_savings_year20(Some(Money::default()/* use setters */));
    /// let x = SavingsOverTime::new().set_or_clear_present_value_of_savings_year20(None::<Money>);
    /// ```
    pub fn set_or_clear_present_value_of_savings_year20<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.present_value_of_savings_year20 = v.map(|x| x.into());
        self
    }

    /// Sets the value of [savings_lifetime][crate::model::SavingsOverTime::savings_lifetime].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SavingsOverTime;
    /// use google_cloud_type::model::Money;
    /// let x = SavingsOverTime::new().set_savings_lifetime(Money::default()/* use setters */);
    /// ```
    pub fn set_savings_lifetime<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.savings_lifetime = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [savings_lifetime][crate::model::SavingsOverTime::savings_lifetime].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SavingsOverTime;
    /// use google_cloud_type::model::Money;
    /// let x = SavingsOverTime::new().set_or_clear_savings_lifetime(Some(Money::default()/* use setters */));
    /// let x = SavingsOverTime::new().set_or_clear_savings_lifetime(None::<Money>);
    /// ```
    pub fn set_or_clear_savings_lifetime<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.savings_lifetime = v.map(|x| x.into());
        self
    }

    /// Sets the value of [present_value_of_savings_lifetime][crate::model::SavingsOverTime::present_value_of_savings_lifetime].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SavingsOverTime;
    /// use google_cloud_type::model::Money;
    /// let x = SavingsOverTime::new().set_present_value_of_savings_lifetime(Money::default()/* use setters */);
    /// ```
    pub fn set_present_value_of_savings_lifetime<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.present_value_of_savings_lifetime = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [present_value_of_savings_lifetime][crate::model::SavingsOverTime::present_value_of_savings_lifetime].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SavingsOverTime;
    /// use google_cloud_type::model::Money;
    /// let x = SavingsOverTime::new().set_or_clear_present_value_of_savings_lifetime(Some(Money::default()/* use setters */));
    /// let x = SavingsOverTime::new().set_or_clear_present_value_of_savings_lifetime(None::<Money>);
    /// ```
    pub fn set_or_clear_present_value_of_savings_lifetime<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.present_value_of_savings_lifetime = v.map(|x| x.into());
        self
    }

    /// Sets the value of [financially_viable][crate::model::SavingsOverTime::financially_viable].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::SavingsOverTime;
    /// let x = SavingsOverTime::new().set_financially_viable(true);
    /// ```
    pub fn set_financially_viable<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.financially_viable = v.into();
        self
    }
}

impl wkt::message::Message for SavingsOverTime {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.SavingsOverTime"
    }
}

/// Cost and benefit of leasing a particular configuration of solar panels
/// with a particular electricity usage.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LeasingSavings {
    /// Whether leases are allowed in this juristiction (leases are not
    /// allowed in some states). If this field is false, then the values in
    /// this message should probably be ignored.
    pub leases_allowed: bool,

    /// Whether leases are supported in this juristiction by the financial
    /// calculation engine. If this field is false, then the values in this
    /// message should probably be ignored. This is independent of
    /// `leases_allowed`: in some areas leases are allowed, but under conditions
    /// that aren't handled by the financial models.
    pub leases_supported: bool,

    /// Estimated annual leasing cost.
    pub annual_leasing_cost: std::option::Option<google_cloud_type::model::Money>,

    /// How much is saved (or not) over the lifetime period.
    pub savings: std::option::Option<crate::model::SavingsOverTime>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl LeasingSavings {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [leases_allowed][crate::model::LeasingSavings::leases_allowed].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::LeasingSavings;
    /// let x = LeasingSavings::new().set_leases_allowed(true);
    /// ```
    pub fn set_leases_allowed<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.leases_allowed = v.into();
        self
    }

    /// Sets the value of [leases_supported][crate::model::LeasingSavings::leases_supported].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::LeasingSavings;
    /// let x = LeasingSavings::new().set_leases_supported(true);
    /// ```
    pub fn set_leases_supported<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.leases_supported = v.into();
        self
    }

    /// Sets the value of [annual_leasing_cost][crate::model::LeasingSavings::annual_leasing_cost].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::LeasingSavings;
    /// use google_cloud_type::model::Money;
    /// let x = LeasingSavings::new().set_annual_leasing_cost(Money::default()/* use setters */);
    /// ```
    pub fn set_annual_leasing_cost<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.annual_leasing_cost = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [annual_leasing_cost][crate::model::LeasingSavings::annual_leasing_cost].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::LeasingSavings;
    /// use google_cloud_type::model::Money;
    /// let x = LeasingSavings::new().set_or_clear_annual_leasing_cost(Some(Money::default()/* use setters */));
    /// let x = LeasingSavings::new().set_or_clear_annual_leasing_cost(None::<Money>);
    /// ```
    pub fn set_or_clear_annual_leasing_cost<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.annual_leasing_cost = v.map(|x| x.into());
        self
    }

    /// Sets the value of [savings][crate::model::LeasingSavings::savings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::LeasingSavings;
    /// use google_maps_solar_v1::model::SavingsOverTime;
    /// let x = LeasingSavings::new().set_savings(SavingsOverTime::default()/* use setters */);
    /// ```
    pub fn set_savings<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SavingsOverTime>,
    {
        self.savings = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [savings][crate::model::LeasingSavings::savings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::LeasingSavings;
    /// use google_maps_solar_v1::model::SavingsOverTime;
    /// let x = LeasingSavings::new().set_or_clear_savings(Some(SavingsOverTime::default()/* use setters */));
    /// let x = LeasingSavings::new().set_or_clear_savings(None::<SavingsOverTime>);
    /// ```
    pub fn set_or_clear_savings<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SavingsOverTime>,
    {
        self.savings = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for LeasingSavings {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.LeasingSavings"
    }
}

/// Cost and benefit of an outright purchase of a particular configuration
/// of solar panels with a particular electricity usage.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CashPurchaseSavings {
    /// Initial cost before tax incentives: the amount that must be paid
    /// out-of-pocket. Contrast with `upfront_cost`, which is after tax incentives.
    pub out_of_pocket_cost: std::option::Option<google_cloud_type::model::Money>,

    /// Initial cost after tax incentives: it's the amount that must be paid
    /// during first year. Contrast with `out_of_pocket_cost`, which is before tax
    /// incentives.
    pub upfront_cost: std::option::Option<google_cloud_type::model::Money>,

    /// The value of all tax rebates.
    pub rebate_value: std::option::Option<google_cloud_type::model::Money>,

    /// Number of years until payback occurs. A negative value means payback
    /// never occurs within the lifetime period.
    pub payback_years: std::option::Option<f32>,

    /// How much is saved (or not) over the lifetime period.
    pub savings: std::option::Option<crate::model::SavingsOverTime>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CashPurchaseSavings {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [out_of_pocket_cost][crate::model::CashPurchaseSavings::out_of_pocket_cost].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::CashPurchaseSavings;
    /// use google_cloud_type::model::Money;
    /// let x = CashPurchaseSavings::new().set_out_of_pocket_cost(Money::default()/* use setters */);
    /// ```
    pub fn set_out_of_pocket_cost<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.out_of_pocket_cost = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [out_of_pocket_cost][crate::model::CashPurchaseSavings::out_of_pocket_cost].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::CashPurchaseSavings;
    /// use google_cloud_type::model::Money;
    /// let x = CashPurchaseSavings::new().set_or_clear_out_of_pocket_cost(Some(Money::default()/* use setters */));
    /// let x = CashPurchaseSavings::new().set_or_clear_out_of_pocket_cost(None::<Money>);
    /// ```
    pub fn set_or_clear_out_of_pocket_cost<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.out_of_pocket_cost = v.map(|x| x.into());
        self
    }

    /// Sets the value of [upfront_cost][crate::model::CashPurchaseSavings::upfront_cost].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::CashPurchaseSavings;
    /// use google_cloud_type::model::Money;
    /// let x = CashPurchaseSavings::new().set_upfront_cost(Money::default()/* use setters */);
    /// ```
    pub fn set_upfront_cost<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.upfront_cost = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [upfront_cost][crate::model::CashPurchaseSavings::upfront_cost].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::CashPurchaseSavings;
    /// use google_cloud_type::model::Money;
    /// let x = CashPurchaseSavings::new().set_or_clear_upfront_cost(Some(Money::default()/* use setters */));
    /// let x = CashPurchaseSavings::new().set_or_clear_upfront_cost(None::<Money>);
    /// ```
    pub fn set_or_clear_upfront_cost<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.upfront_cost = v.map(|x| x.into());
        self
    }

    /// Sets the value of [rebate_value][crate::model::CashPurchaseSavings::rebate_value].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::CashPurchaseSavings;
    /// use google_cloud_type::model::Money;
    /// let x = CashPurchaseSavings::new().set_rebate_value(Money::default()/* use setters */);
    /// ```
    pub fn set_rebate_value<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.rebate_value = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [rebate_value][crate::model::CashPurchaseSavings::rebate_value].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::CashPurchaseSavings;
    /// use google_cloud_type::model::Money;
    /// let x = CashPurchaseSavings::new().set_or_clear_rebate_value(Some(Money::default()/* use setters */));
    /// let x = CashPurchaseSavings::new().set_or_clear_rebate_value(None::<Money>);
    /// ```
    pub fn set_or_clear_rebate_value<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.rebate_value = v.map(|x| x.into());
        self
    }

    /// Sets the value of [payback_years][crate::model::CashPurchaseSavings::payback_years].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::CashPurchaseSavings;
    /// let x = CashPurchaseSavings::new().set_payback_years(42.0);
    /// ```
    pub fn set_payback_years<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.payback_years = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [payback_years][crate::model::CashPurchaseSavings::payback_years].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::CashPurchaseSavings;
    /// let x = CashPurchaseSavings::new().set_or_clear_payback_years(Some(42.0));
    /// let x = CashPurchaseSavings::new().set_or_clear_payback_years(None::<f32>);
    /// ```
    pub fn set_or_clear_payback_years<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<f32>,
    {
        self.payback_years = v.map(|x| x.into());
        self
    }

    /// Sets the value of [savings][crate::model::CashPurchaseSavings::savings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::CashPurchaseSavings;
    /// use google_maps_solar_v1::model::SavingsOverTime;
    /// let x = CashPurchaseSavings::new().set_savings(SavingsOverTime::default()/* use setters */);
    /// ```
    pub fn set_savings<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SavingsOverTime>,
    {
        self.savings = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [savings][crate::model::CashPurchaseSavings::savings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::CashPurchaseSavings;
    /// use google_maps_solar_v1::model::SavingsOverTime;
    /// let x = CashPurchaseSavings::new().set_or_clear_savings(Some(SavingsOverTime::default()/* use setters */));
    /// let x = CashPurchaseSavings::new().set_or_clear_savings(None::<SavingsOverTime>);
    /// ```
    pub fn set_or_clear_savings<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SavingsOverTime>,
    {
        self.savings = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for CashPurchaseSavings {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.CashPurchaseSavings"
    }
}

/// Cost and benefit of using a loan to buy a particular configuration
/// of solar panels with a particular electricity usage.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FinancedPurchaseSavings {
    /// Annual loan payments.
    pub annual_loan_payment: std::option::Option<google_cloud_type::model::Money>,

    /// The value of all tax rebates (including Federal Investment Tax Credit
    /// (ITC)).
    pub rebate_value: std::option::Option<google_cloud_type::model::Money>,

    /// The interest rate on loans assumed in this set of calculations.
    pub loan_interest_rate: f32,

    /// How much is saved (or not) over the lifetime period.
    pub savings: std::option::Option<crate::model::SavingsOverTime>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FinancedPurchaseSavings {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [annual_loan_payment][crate::model::FinancedPurchaseSavings::annual_loan_payment].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancedPurchaseSavings;
    /// use google_cloud_type::model::Money;
    /// let x = FinancedPurchaseSavings::new().set_annual_loan_payment(Money::default()/* use setters */);
    /// ```
    pub fn set_annual_loan_payment<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.annual_loan_payment = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [annual_loan_payment][crate::model::FinancedPurchaseSavings::annual_loan_payment].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancedPurchaseSavings;
    /// use google_cloud_type::model::Money;
    /// let x = FinancedPurchaseSavings::new().set_or_clear_annual_loan_payment(Some(Money::default()/* use setters */));
    /// let x = FinancedPurchaseSavings::new().set_or_clear_annual_loan_payment(None::<Money>);
    /// ```
    pub fn set_or_clear_annual_loan_payment<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.annual_loan_payment = v.map(|x| x.into());
        self
    }

    /// Sets the value of [rebate_value][crate::model::FinancedPurchaseSavings::rebate_value].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancedPurchaseSavings;
    /// use google_cloud_type::model::Money;
    /// let x = FinancedPurchaseSavings::new().set_rebate_value(Money::default()/* use setters */);
    /// ```
    pub fn set_rebate_value<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.rebate_value = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [rebate_value][crate::model::FinancedPurchaseSavings::rebate_value].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancedPurchaseSavings;
    /// use google_cloud_type::model::Money;
    /// let x = FinancedPurchaseSavings::new().set_or_clear_rebate_value(Some(Money::default()/* use setters */));
    /// let x = FinancedPurchaseSavings::new().set_or_clear_rebate_value(None::<Money>);
    /// ```
    pub fn set_or_clear_rebate_value<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Money>,
    {
        self.rebate_value = v.map(|x| x.into());
        self
    }

    /// Sets the value of [loan_interest_rate][crate::model::FinancedPurchaseSavings::loan_interest_rate].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancedPurchaseSavings;
    /// let x = FinancedPurchaseSavings::new().set_loan_interest_rate(42.0);
    /// ```
    pub fn set_loan_interest_rate<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.loan_interest_rate = v.into();
        self
    }

    /// Sets the value of [savings][crate::model::FinancedPurchaseSavings::savings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancedPurchaseSavings;
    /// use google_maps_solar_v1::model::SavingsOverTime;
    /// let x = FinancedPurchaseSavings::new().set_savings(SavingsOverTime::default()/* use setters */);
    /// ```
    pub fn set_savings<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SavingsOverTime>,
    {
        self.savings = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [savings][crate::model::FinancedPurchaseSavings::savings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::FinancedPurchaseSavings;
    /// use google_maps_solar_v1::model::SavingsOverTime;
    /// let x = FinancedPurchaseSavings::new().set_or_clear_savings(Some(SavingsOverTime::default()/* use setters */));
    /// let x = FinancedPurchaseSavings::new().set_or_clear_savings(None::<SavingsOverTime>);
    /// ```
    pub fn set_or_clear_savings<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SavingsOverTime>,
    {
        self.savings = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for FinancedPurchaseSavings {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.FinancedPurchaseSavings"
    }
}

/// Request message for `Solar.GetDataLayers`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetDataLayersRequest {
    /// Required. The longitude and latitude for the center of the region to get
    /// data for.
    pub location: std::option::Option<google_cloud_type::model::LatLng>,

    /// Required. The radius, in meters, defining the region surrounding that
    /// centre point for which data should be returned. The limitations
    /// on this value are:
    ///
    /// * Any value up to 100m can always be specified.
    /// * Values over 100m can be specified, as long as
    ///   `radius_meters` <= `pixel_size_meters * 1000`.
    /// * However, for values over 175m, the `DataLayerView` in the
    ///   request must not include monthly flux or hourly shade.
    pub radius_meters: f32,

    /// Optional. The desired subset of the data to return.
    pub view: crate::model::DataLayerView,

    /// Optional. The minimum quality level allowed in the results. No result with
    /// lower quality than this will be returned. Not specifying this is
    /// equivalent to restricting to HIGH quality only.
    pub required_quality: crate::model::ImageryQuality,

    /// Optional. The minimum scale, in meters per pixel, of the data to return.
    /// Values of 0.1 (the default, if this field is not set explicitly),
    /// 0.25, 0.5, and 1.0 are supported. Imagery components whose normal
    /// resolution is less than `pixel_size_meters` will be returned at
    /// the resolution specified by `pixel_size_meters`; imagery
    /// components whose normal resolution is equal to or greater than
    /// `pixel_size_meters` will be returned at that normal resolution.
    pub pixel_size_meters: f32,

    /// Optional. Whether to require exact quality of the imagery.
    /// If set to false, the `required_quality` field is interpreted as the minimum
    /// required quality, such that HIGH quality imagery may be returned when
    /// `required_quality` is set to MEDIUM.  If set to true, `required_quality`
    /// is interpreted as the exact required quality and only `MEDIUM` quality
    /// imagery is returned if `required_quality` is set to `MEDIUM`.
    pub exact_quality_required: bool,

    /// Optional. Specifies the pre-GA experiments to enable.
    pub experiments: std::vec::Vec<crate::model::Experiment>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetDataLayersRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [location][crate::model::GetDataLayersRequest::location].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::GetDataLayersRequest;
    /// use google_cloud_type::model::LatLng;
    /// let x = GetDataLayersRequest::new().set_location(LatLng::default()/* use setters */);
    /// ```
    pub fn set_location<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.location = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [location][crate::model::GetDataLayersRequest::location].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::GetDataLayersRequest;
    /// use google_cloud_type::model::LatLng;
    /// let x = GetDataLayersRequest::new().set_or_clear_location(Some(LatLng::default()/* use setters */));
    /// let x = GetDataLayersRequest::new().set_or_clear_location(None::<LatLng>);
    /// ```
    pub fn set_or_clear_location<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::LatLng>,
    {
        self.location = v.map(|x| x.into());
        self
    }

    /// Sets the value of [radius_meters][crate::model::GetDataLayersRequest::radius_meters].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::GetDataLayersRequest;
    /// let x = GetDataLayersRequest::new().set_radius_meters(42.0);
    /// ```
    pub fn set_radius_meters<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.radius_meters = v.into();
        self
    }

    /// Sets the value of [view][crate::model::GetDataLayersRequest::view].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::GetDataLayersRequest;
    /// use google_maps_solar_v1::model::DataLayerView;
    /// let x0 = GetDataLayersRequest::new().set_view(DataLayerView::DsmLayer);
    /// let x1 = GetDataLayersRequest::new().set_view(DataLayerView::ImageryLayers);
    /// let x2 = GetDataLayersRequest::new().set_view(DataLayerView::ImageryAndAnnualFluxLayers);
    /// ```
    pub fn set_view<T: std::convert::Into<crate::model::DataLayerView>>(mut self, v: T) -> Self {
        self.view = v.into();
        self
    }

    /// Sets the value of [required_quality][crate::model::GetDataLayersRequest::required_quality].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::GetDataLayersRequest;
    /// use google_maps_solar_v1::model::ImageryQuality;
    /// let x0 = GetDataLayersRequest::new().set_required_quality(ImageryQuality::High);
    /// let x1 = GetDataLayersRequest::new().set_required_quality(ImageryQuality::Medium);
    /// let x2 = GetDataLayersRequest::new().set_required_quality(ImageryQuality::Low);
    /// ```
    pub fn set_required_quality<T: std::convert::Into<crate::model::ImageryQuality>>(
        mut self,
        v: T,
    ) -> Self {
        self.required_quality = v.into();
        self
    }

    /// Sets the value of [pixel_size_meters][crate::model::GetDataLayersRequest::pixel_size_meters].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::GetDataLayersRequest;
    /// let x = GetDataLayersRequest::new().set_pixel_size_meters(42.0);
    /// ```
    pub fn set_pixel_size_meters<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
        self.pixel_size_meters = v.into();
        self
    }

    /// Sets the value of [exact_quality_required][crate::model::GetDataLayersRequest::exact_quality_required].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::GetDataLayersRequest;
    /// let x = GetDataLayersRequest::new().set_exact_quality_required(true);
    /// ```
    pub fn set_exact_quality_required<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.exact_quality_required = v.into();
        self
    }

    /// Sets the value of [experiments][crate::model::GetDataLayersRequest::experiments].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::GetDataLayersRequest;
    /// use google_maps_solar_v1::model::Experiment;
    /// let x = GetDataLayersRequest::new().set_experiments([
    ///     Experiment::ExpandedCoverage,
    /// ]);
    /// ```
    pub fn set_experiments<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Experiment>,
    {
        use std::iter::Iterator;
        self.experiments = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for GetDataLayersRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.GetDataLayersRequest"
    }
}

/// Information about the solar potential of a region. The actual data
/// are contained in a number of GeoTIFF files covering the requested
/// region, for which this message contains URLs: Each string in the
/// `DataLayers` message contains a URL from which the
/// corresponding GeoTIFF can be fetched. These URLs are valid for a
/// few hours after they've been generated. Most of the GeoTIFF files
/// are at a resolution of 0.1m/pixel, but the monthly flux file is at
/// 0.5m/pixel, and the hourly shade files are at 1m/pixel. If a
/// `pixel_size_meters` value was specified in the
/// `GetDataLayersRequest`, then the minimum resolution in the GeoTIFF
/// files will be that value.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DataLayers {
    /// When the source imagery (from which all the other data are derived) in this
    /// region was taken. It is necessarily somewhat approximate, as the images may
    /// have been taken over more than one day.
    pub imagery_date: std::option::Option<google_cloud_type::model::Date>,

    /// When processing was completed on this imagery.
    pub imagery_processed_date: std::option::Option<google_cloud_type::model::Date>,

    /// The URL for an image of the DSM (Digital Surface Model) of the region.
    /// Values are in meters above EGM96 geoid (i.e., sea level). Invalid locations
    /// (where we don't have data) are stored as -9999.
    pub dsm_url: std::string::String,

    /// The URL for an image of RGB data (aerial or satellite photo) of the region.
    pub rgb_url: std::string::String,

    /// The URL for the building mask image: one bit per pixel saying whether that
    /// pixel is considered to be part of a rooftop or not.
    pub mask_url: std::string::String,

    /// The URL for the annual flux map (annual sunlight on roofs) of the region.
    /// Values are kWh/kW/year. This is *unmasked flux*: flux is computed for every
    /// location, not just building rooftops. Invalid locations are stored as
    /// -9999: locations outside our coverage area will be invalid, and a few
    /// locations inside the coverage area, where we were unable to calculate flux,
    /// will also be invalid.
    pub annual_flux_url: std::string::String,

    /// The URL for the monthly flux map (sunlight on roofs, broken down by month)
    /// of the region. Values are kWh/kW/year. The GeoTIFF pointed to by this URL
    /// will contain twelve bands, corresponding to January...December, in order.
    pub monthly_flux_url: std::string::String,

    /// Twelve URLs for hourly shade, corresponding to January...December, in
    /// order. Each GeoTIFF will contain 24 bands, corresponding to the 24 hours of
    /// the day. Each pixel is a 32 bit integer, corresponding to the (up to) 31
    /// days of that month; a 1 bit means that the corresponding location is able
    /// to see the sun at that day, of that hour, of that month. Invalid locations
    /// are stored as -9999 (since this is negative, it has bit 31 set, and no
    /// valid value could have bit 31 set as that would correspond to the 32nd day
    /// of the month).
    ///
    /// An example may be useful. If you want to know whether a point (at
    /// pixel location (x, y)) saw sun at 4pm on the 22nd of June you
    /// would:
    ///
    /// 1. fetch the sixth URL in this list (corresponding to June).
    /// 1. look up the 17th channel (corresponding to 4pm).
    /// 1. read the 32-bit value at (x, y).
    /// 1. read bit 21 of the value (corresponding to the 22nd of the month).
    /// 1. if that bit is a 1, then that spot saw the sun at 4pm 22 June.
    ///
    /// More formally:
    /// Given `month` (1-12), `day` (1...month max; February has 28 days)
    /// and `hour` (0-23), the shade/sun for that month/day/hour at a
    /// position `(x, y)` is the bit
    ///
    /// ```norust
    /// (hourly_shade[month - 1])(x, y)[hour] & (1 << (day - 1))
    /// ```
    ///
    /// where `(x, y)` is spatial indexing, `[month - 1]` refers to
    /// fetching the `month - 1`st URL (indexing from zero), `[hour]` is
    /// indexing into the channels, and a final non-zero result means
    /// "sunny". There are no leap days, and DST doesn't exist (all days
    /// are 24 hours long; noon is always "standard time" noon).
    pub hourly_shade_urls: std::vec::Vec<std::string::String>,

    /// The quality of the result's imagery.
    pub imagery_quality: crate::model::ImageryQuality,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DataLayers {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [imagery_date][crate::model::DataLayers::imagery_date].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::DataLayers;
    /// use google_cloud_type::model::Date;
    /// let x = DataLayers::new().set_imagery_date(Date::default()/* use setters */);
    /// ```
    pub fn set_imagery_date<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Date>,
    {
        self.imagery_date = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [imagery_date][crate::model::DataLayers::imagery_date].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::DataLayers;
    /// use google_cloud_type::model::Date;
    /// let x = DataLayers::new().set_or_clear_imagery_date(Some(Date::default()/* use setters */));
    /// let x = DataLayers::new().set_or_clear_imagery_date(None::<Date>);
    /// ```
    pub fn set_or_clear_imagery_date<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Date>,
    {
        self.imagery_date = v.map(|x| x.into());
        self
    }

    /// Sets the value of [imagery_processed_date][crate::model::DataLayers::imagery_processed_date].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::DataLayers;
    /// use google_cloud_type::model::Date;
    /// let x = DataLayers::new().set_imagery_processed_date(Date::default()/* use setters */);
    /// ```
    pub fn set_imagery_processed_date<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Date>,
    {
        self.imagery_processed_date = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [imagery_processed_date][crate::model::DataLayers::imagery_processed_date].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::DataLayers;
    /// use google_cloud_type::model::Date;
    /// let x = DataLayers::new().set_or_clear_imagery_processed_date(Some(Date::default()/* use setters */));
    /// let x = DataLayers::new().set_or_clear_imagery_processed_date(None::<Date>);
    /// ```
    pub fn set_or_clear_imagery_processed_date<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Date>,
    {
        self.imagery_processed_date = v.map(|x| x.into());
        self
    }

    /// Sets the value of [dsm_url][crate::model::DataLayers::dsm_url].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::DataLayers;
    /// let x = DataLayers::new().set_dsm_url("example");
    /// ```
    pub fn set_dsm_url<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.dsm_url = v.into();
        self
    }

    /// Sets the value of [rgb_url][crate::model::DataLayers::rgb_url].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::DataLayers;
    /// let x = DataLayers::new().set_rgb_url("example");
    /// ```
    pub fn set_rgb_url<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.rgb_url = v.into();
        self
    }

    /// Sets the value of [mask_url][crate::model::DataLayers::mask_url].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::DataLayers;
    /// let x = DataLayers::new().set_mask_url("example");
    /// ```
    pub fn set_mask_url<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.mask_url = v.into();
        self
    }

    /// Sets the value of [annual_flux_url][crate::model::DataLayers::annual_flux_url].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::DataLayers;
    /// let x = DataLayers::new().set_annual_flux_url("example");
    /// ```
    pub fn set_annual_flux_url<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.annual_flux_url = v.into();
        self
    }

    /// Sets the value of [monthly_flux_url][crate::model::DataLayers::monthly_flux_url].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::DataLayers;
    /// let x = DataLayers::new().set_monthly_flux_url("example");
    /// ```
    pub fn set_monthly_flux_url<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.monthly_flux_url = v.into();
        self
    }

    /// Sets the value of [hourly_shade_urls][crate::model::DataLayers::hourly_shade_urls].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::DataLayers;
    /// let x = DataLayers::new().set_hourly_shade_urls(["a", "b", "c"]);
    /// ```
    pub fn set_hourly_shade_urls<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.hourly_shade_urls = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [imagery_quality][crate::model::DataLayers::imagery_quality].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::DataLayers;
    /// use google_maps_solar_v1::model::ImageryQuality;
    /// let x0 = DataLayers::new().set_imagery_quality(ImageryQuality::High);
    /// let x1 = DataLayers::new().set_imagery_quality(ImageryQuality::Medium);
    /// let x2 = DataLayers::new().set_imagery_quality(ImageryQuality::Low);
    /// ```
    pub fn set_imagery_quality<T: std::convert::Into<crate::model::ImageryQuality>>(
        mut self,
        v: T,
    ) -> Self {
        self.imagery_quality = v.into();
        self
    }
}

impl wkt::message::Message for DataLayers {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.DataLayers"
    }
}

/// Request message for `Solar.GetGeoTiff`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetGeoTiffRequest {
    /// Required. The ID of the asset being requested.
    pub id: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetGeoTiffRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [id][crate::model::GetGeoTiffRequest::id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_solar_v1::model::GetGeoTiffRequest;
    /// let x = GetGeoTiffRequest::new().set_id("example");
    /// ```
    pub fn set_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.id = v.into();
        self
    }
}

impl wkt::message::Message for GetGeoTiffRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.maps.solar.v1.GetGeoTiffRequest"
    }
}

/// What subset of the solar information to return.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum DataLayerView {
    /// Equivalent to FULL.
    Unspecified,
    /// Get the DSM only.
    DsmLayer,
    /// Get the DSM, RGB, and mask.
    ImageryLayers,
    /// Get the DSM, RGB, mask, and annual flux.
    ImageryAndAnnualFluxLayers,
    /// Get the DSM, RGB, mask, annual flux, and monthly flux.
    ImageryAndAllFluxLayers,
    /// Get all data.
    FullLayers,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [DataLayerView::value] or
    /// [DataLayerView::name].
    UnknownValue(data_layer_view::UnknownValue),
}

#[doc(hidden)]
pub mod data_layer_view {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl DataLayerView {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::DsmLayer => std::option::Option::Some(1),
            Self::ImageryLayers => std::option::Option::Some(2),
            Self::ImageryAndAnnualFluxLayers => std::option::Option::Some(3),
            Self::ImageryAndAllFluxLayers => std::option::Option::Some(4),
            Self::FullLayers => std::option::Option::Some(5),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("DATA_LAYER_VIEW_UNSPECIFIED"),
            Self::DsmLayer => std::option::Option::Some("DSM_LAYER"),
            Self::ImageryLayers => std::option::Option::Some("IMAGERY_LAYERS"),
            Self::ImageryAndAnnualFluxLayers => {
                std::option::Option::Some("IMAGERY_AND_ANNUAL_FLUX_LAYERS")
            }
            Self::ImageryAndAllFluxLayers => {
                std::option::Option::Some("IMAGERY_AND_ALL_FLUX_LAYERS")
            }
            Self::FullLayers => std::option::Option::Some("FULL_LAYERS"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for DataLayerView {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for DataLayerView {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for DataLayerView {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::DsmLayer,
            2 => Self::ImageryLayers,
            3 => Self::ImageryAndAnnualFluxLayers,
            4 => Self::ImageryAndAllFluxLayers,
            5 => Self::FullLayers,
            _ => Self::UnknownValue(data_layer_view::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for DataLayerView {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "DATA_LAYER_VIEW_UNSPECIFIED" => Self::Unspecified,
            "DSM_LAYER" => Self::DsmLayer,
            "IMAGERY_LAYERS" => Self::ImageryLayers,
            "IMAGERY_AND_ANNUAL_FLUX_LAYERS" => Self::ImageryAndAnnualFluxLayers,
            "IMAGERY_AND_ALL_FLUX_LAYERS" => Self::ImageryAndAllFluxLayers,
            "FULL_LAYERS" => Self::FullLayers,
            _ => Self::UnknownValue(data_layer_view::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for DataLayerView {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::DsmLayer => serializer.serialize_i32(1),
            Self::ImageryLayers => serializer.serialize_i32(2),
            Self::ImageryAndAnnualFluxLayers => serializer.serialize_i32(3),
            Self::ImageryAndAllFluxLayers => serializer.serialize_i32(4),
            Self::FullLayers => serializer.serialize_i32(5),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for DataLayerView {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<DataLayerView>::new(
            ".google.maps.solar.v1.DataLayerView",
        ))
    }
}

/// The quality of the imagery used to compute some API result.
///
/// Note: Regardless of imagery quality level, DSM outputs always have a
/// resolution of 0.1 m/pixel, monthly flux outputs always have a resolution of
/// 0.5 m/pixel, and hourly shade outputs always have a resolution of 1 m/pixel.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum ImageryQuality {
    /// No quality is known.
    Unspecified,
    /// Solar data is derived from aerial imagery captured at low-altitude and
    /// processed at 0.1 m/pixel.
    High,
    /// Solar data is derived from enhanced aerial imagery captured at
    /// high-altitude and processed at 0.25 m/pixel.
    Medium,
    /// Solar data is derived from enhanced satellite imagery processed at 0.25
    /// m/pixel.
    Low,
    /// Solar data is derived from enhanced satellite imagery processed at 0.25
    /// m/pixel.
    Base,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [ImageryQuality::value] or
    /// [ImageryQuality::name].
    UnknownValue(imagery_quality::UnknownValue),
}

#[doc(hidden)]
pub mod imagery_quality {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl ImageryQuality {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::High => std::option::Option::Some(1),
            Self::Medium => std::option::Option::Some(2),
            Self::Low => std::option::Option::Some(3),
            Self::Base => std::option::Option::Some(4),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("IMAGERY_QUALITY_UNSPECIFIED"),
            Self::High => std::option::Option::Some("HIGH"),
            Self::Medium => std::option::Option::Some("MEDIUM"),
            Self::Low => std::option::Option::Some("LOW"),
            Self::Base => std::option::Option::Some("BASE"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for ImageryQuality {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for ImageryQuality {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for ImageryQuality {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::High,
            2 => Self::Medium,
            3 => Self::Low,
            4 => Self::Base,
            _ => Self::UnknownValue(imagery_quality::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for ImageryQuality {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "IMAGERY_QUALITY_UNSPECIFIED" => Self::Unspecified,
            "HIGH" => Self::High,
            "MEDIUM" => Self::Medium,
            "LOW" => Self::Low,
            "BASE" => Self::Base,
            _ => Self::UnknownValue(imagery_quality::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for ImageryQuality {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::High => serializer.serialize_i32(1),
            Self::Medium => serializer.serialize_i32(2),
            Self::Low => serializer.serialize_i32(3),
            Self::Base => serializer.serialize_i32(4),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for ImageryQuality {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<ImageryQuality>::new(
            ".google.maps.solar.v1.ImageryQuality",
        ))
    }
}

/// The orientation of a solar panel. This must be interpreted relative to the
/// azimuth of the roof segment that the panel is placed on.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum SolarPanelOrientation {
    /// No panel orientation is known.
    Unspecified,
    /// A `LANDSCAPE` panel has its long edge perpendicular to the
    /// azimuth direction of the roof segment that it is placed on.
    Landscape,
    /// A `PORTRAIT` panel has its long edge parallel to the azimuth
    /// direction of the roof segment that it is placed on.
    Portrait,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [SolarPanelOrientation::value] or
    /// [SolarPanelOrientation::name].
    UnknownValue(solar_panel_orientation::UnknownValue),
}

#[doc(hidden)]
pub mod solar_panel_orientation {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl SolarPanelOrientation {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::Landscape => std::option::Option::Some(1),
            Self::Portrait => std::option::Option::Some(2),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("SOLAR_PANEL_ORIENTATION_UNSPECIFIED"),
            Self::Landscape => std::option::Option::Some("LANDSCAPE"),
            Self::Portrait => std::option::Option::Some("PORTRAIT"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for SolarPanelOrientation {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for SolarPanelOrientation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for SolarPanelOrientation {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::Landscape,
            2 => Self::Portrait,
            _ => Self::UnknownValue(solar_panel_orientation::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for SolarPanelOrientation {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "SOLAR_PANEL_ORIENTATION_UNSPECIFIED" => Self::Unspecified,
            "LANDSCAPE" => Self::Landscape,
            "PORTRAIT" => Self::Portrait,
            _ => Self::UnknownValue(solar_panel_orientation::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for SolarPanelOrientation {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::Landscape => serializer.serialize_i32(1),
            Self::Portrait => serializer.serialize_i32(2),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for SolarPanelOrientation {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<SolarPanelOrientation>::new(
            ".google.maps.solar.v1.SolarPanelOrientation",
        ))
    }
}

/// Specifies pre-GA experiments that can be enabled in the API.
///
/// Requests using this field are classified as a pre-GA offering
/// under the [Google Maps Platform Service Specific
/// Terms](https://cloud.google.com/maps-platform/terms/maps-service-terms). See
/// [launch stage
/// descriptions](https://cloud.google.com/maps-platform/terms/launch-stages) for
/// more details.
///
/// New values may be added to this enum in the future.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum Experiment {
    /// No experiments are specified.
    Unspecified,
    /// Expands the geographic region available for querying solar data. For more
    /// information, see [Expanded
    /// Coverage](https://developers.google.com/maps/documentation/solar/expanded-coverage).
    ExpandedCoverage,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [Experiment::value] or
    /// [Experiment::name].
    UnknownValue(experiment::UnknownValue),
}

#[doc(hidden)]
pub mod experiment {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl Experiment {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::ExpandedCoverage => std::option::Option::Some(1),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("EXPERIMENT_UNSPECIFIED"),
            Self::ExpandedCoverage => std::option::Option::Some("EXPANDED_COVERAGE"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for Experiment {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for Experiment {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for Experiment {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::ExpandedCoverage,
            _ => Self::UnknownValue(experiment::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for Experiment {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "EXPERIMENT_UNSPECIFIED" => Self::Unspecified,
            "EXPANDED_COVERAGE" => Self::ExpandedCoverage,
            _ => Self::UnknownValue(experiment::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for Experiment {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::ExpandedCoverage => serializer.serialize_i32(1),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for Experiment {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<Experiment>::new(
            ".google.maps.solar.v1.Experiment",
        ))
    }
}