#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl serde::ser::Serialize for super::FindClosestBuildingInsightsRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.location.is_some() {
state.serialize_entry("location", &self.location)?;
}
if !wkt::internal::is_default(&self.required_quality) {
state.serialize_entry("requiredQuality", &self.required_quality)?;
}
if !wkt::internal::is_default(&self.exact_quality_required) {
state.serialize_entry("exactQualityRequired", &self.exact_quality_required)?;
}
if !self.experiments.is_empty() {
state.serialize_entry("experiments", &self.experiments)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::LatLngBox {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.sw.is_some() {
state.serialize_entry("sw", &self.sw)?;
}
if self.ne.is_some() {
state.serialize_entry("ne", &self.ne)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::BuildingInsights {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if self.center.is_some() {
state.serialize_entry("center", &self.center)?;
}
if self.bounding_box.is_some() {
state.serialize_entry("boundingBox", &self.bounding_box)?;
}
if self.imagery_date.is_some() {
state.serialize_entry("imageryDate", &self.imagery_date)?;
}
if self.imagery_processed_date.is_some() {
state.serialize_entry("imageryProcessedDate", &self.imagery_processed_date)?;
}
if !self.postal_code.is_empty() {
state.serialize_entry("postalCode", &self.postal_code)?;
}
if !self.administrative_area.is_empty() {
state.serialize_entry("administrativeArea", &self.administrative_area)?;
}
if !self.statistical_area.is_empty() {
state.serialize_entry("statisticalArea", &self.statistical_area)?;
}
if !self.region_code.is_empty() {
state.serialize_entry("regionCode", &self.region_code)?;
}
if self.solar_potential.is_some() {
state.serialize_entry("solarPotential", &self.solar_potential)?;
}
if !wkt::internal::is_default(&self.imagery_quality) {
state.serialize_entry("imageryQuality", &self.imagery_quality)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::SolarPotential {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.max_array_panels_count) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("maxArrayPanelsCount", &__With(&self.max_array_panels_count))?;
}
if !wkt::internal::is_default(&self.panel_capacity_watts) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry("panelCapacityWatts", &__With(&self.panel_capacity_watts))?;
}
if !wkt::internal::is_default(&self.panel_height_meters) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry("panelHeightMeters", &__With(&self.panel_height_meters))?;
}
if !wkt::internal::is_default(&self.panel_width_meters) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry("panelWidthMeters", &__With(&self.panel_width_meters))?;
}
if !wkt::internal::is_default(&self.panel_lifetime_years) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("panelLifetimeYears", &__With(&self.panel_lifetime_years))?;
}
if !wkt::internal::is_default(&self.max_array_area_meters2) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry("maxArrayAreaMeters2", &__With(&self.max_array_area_meters2))?;
}
if !wkt::internal::is_default(&self.max_sunshine_hours_per_year) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"maxSunshineHoursPerYear",
&__With(&self.max_sunshine_hours_per_year),
)?;
}
if !wkt::internal::is_default(&self.carbon_offset_factor_kg_per_mwh) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"carbonOffsetFactorKgPerMwh",
&__With(&self.carbon_offset_factor_kg_per_mwh),
)?;
}
if self.whole_roof_stats.is_some() {
state.serialize_entry("wholeRoofStats", &self.whole_roof_stats)?;
}
if self.building_stats.is_some() {
state.serialize_entry("buildingStats", &self.building_stats)?;
}
if !self.roof_segment_stats.is_empty() {
state.serialize_entry("roofSegmentStats", &self.roof_segment_stats)?;
}
if !self.solar_panels.is_empty() {
state.serialize_entry("solarPanels", &self.solar_panels)?;
}
if !self.solar_panel_configs.is_empty() {
state.serialize_entry("solarPanelConfigs", &self.solar_panel_configs)?;
}
if !self.financial_analyses.is_empty() {
state.serialize_entry("financialAnalyses", &self.financial_analyses)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::RoofSegmentSizeAndSunshineStats {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.pitch_degrees.is_some() {
struct __With<'a>(&'a std::option::Option<f32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("pitchDegrees", &__With(&self.pitch_degrees))?;
}
if self.azimuth_degrees.is_some() {
struct __With<'a>(&'a std::option::Option<f32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("azimuthDegrees", &__With(&self.azimuth_degrees))?;
}
if self.stats.is_some() {
state.serialize_entry("stats", &self.stats)?;
}
if self.center.is_some() {
state.serialize_entry("center", &self.center)?;
}
if self.bounding_box.is_some() {
state.serialize_entry("boundingBox", &self.bounding_box)?;
}
if self.plane_height_at_center_meters.is_some() {
struct __With<'a>(&'a std::option::Option<f32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"planeHeightAtCenterMeters",
&__With(&self.plane_height_at_center_meters),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::SizeAndSunshineStats {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.area_meters2) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry("areaMeters2", &__With(&self.area_meters2))?;
}
if !self.sunshine_quantiles.is_empty() {
struct __With<'a>(&'a std::vec::Vec<f32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::F32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("sunshineQuantiles", &__With(&self.sunshine_quantiles))?;
}
if !wkt::internal::is_default(&self.ground_area_meters2) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry("groundAreaMeters2", &__With(&self.ground_area_meters2))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::SolarPanel {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.center.is_some() {
state.serialize_entry("center", &self.center)?;
}
if !wkt::internal::is_default(&self.orientation) {
state.serialize_entry("orientation", &self.orientation)?;
}
if !wkt::internal::is_default(&self.yearly_energy_dc_kwh) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry("yearlyEnergyDcKwh", &__With(&self.yearly_energy_dc_kwh))?;
}
if self.segment_index.is_some() {
struct __With<'a>(&'a std::option::Option<i32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("segmentIndex", &__With(&self.segment_index))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::SolarPanelConfig {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.panels_count) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("panelsCount", &__With(&self.panels_count))?;
}
if !wkt::internal::is_default(&self.yearly_energy_dc_kwh) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry("yearlyEnergyDcKwh", &__With(&self.yearly_energy_dc_kwh))?;
}
if !self.roof_segment_summaries.is_empty() {
state.serialize_entry("roofSegmentSummaries", &self.roof_segment_summaries)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::RoofSegmentSummary {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.pitch_degrees.is_some() {
struct __With<'a>(&'a std::option::Option<f32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("pitchDegrees", &__With(&self.pitch_degrees))?;
}
if self.azimuth_degrees.is_some() {
struct __With<'a>(&'a std::option::Option<f32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("azimuthDegrees", &__With(&self.azimuth_degrees))?;
}
if !wkt::internal::is_default(&self.panels_count) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("panelsCount", &__With(&self.panels_count))?;
}
if !wkt::internal::is_default(&self.yearly_energy_dc_kwh) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry("yearlyEnergyDcKwh", &__With(&self.yearly_energy_dc_kwh))?;
}
if self.segment_index.is_some() {
struct __With<'a>(&'a std::option::Option<i32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("segmentIndex", &__With(&self.segment_index))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::FinancialAnalysis {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.monthly_bill.is_some() {
state.serialize_entry("monthlyBill", &self.monthly_bill)?;
}
if !wkt::internal::is_default(&self.default_bill) {
state.serialize_entry("defaultBill", &self.default_bill)?;
}
if !wkt::internal::is_default(&self.average_kwh_per_month) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry("averageKwhPerMonth", &__With(&self.average_kwh_per_month))?;
}
if self.panel_config_index.is_some() {
struct __With<'a>(&'a std::option::Option<i32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("panelConfigIndex", &__With(&self.panel_config_index))?;
}
if self.financial_details.is_some() {
state.serialize_entry("financialDetails", &self.financial_details)?;
}
if self.leasing_savings.is_some() {
state.serialize_entry("leasingSavings", &self.leasing_savings)?;
}
if self.cash_purchase_savings.is_some() {
state.serialize_entry("cashPurchaseSavings", &self.cash_purchase_savings)?;
}
if self.financed_purchase_savings.is_some() {
state.serialize_entry("financedPurchaseSavings", &self.financed_purchase_savings)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::FinancialDetails {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.initial_ac_kwh_per_year) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"initialAcKwhPerYear",
&__With(&self.initial_ac_kwh_per_year),
)?;
}
if self.remaining_lifetime_utility_bill.is_some() {
state.serialize_entry(
"remainingLifetimeUtilityBill",
&self.remaining_lifetime_utility_bill,
)?;
}
if self.federal_incentive.is_some() {
state.serialize_entry("federalIncentive", &self.federal_incentive)?;
}
if self.state_incentive.is_some() {
state.serialize_entry("stateIncentive", &self.state_incentive)?;
}
if self.utility_incentive.is_some() {
state.serialize_entry("utilityIncentive", &self.utility_incentive)?;
}
if self.lifetime_srec_total.is_some() {
state.serialize_entry("lifetimeSrecTotal", &self.lifetime_srec_total)?;
}
if self.cost_of_electricity_without_solar.is_some() {
state.serialize_entry(
"costOfElectricityWithoutSolar",
&self.cost_of_electricity_without_solar,
)?;
}
if !wkt::internal::is_default(&self.net_metering_allowed) {
state.serialize_entry("netMeteringAllowed", &self.net_metering_allowed)?;
}
if self.solar_percentage.is_some() {
struct __With<'a>(&'a std::option::Option<f32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("solarPercentage", &__With(&self.solar_percentage))?;
}
if self.percentage_exported_to_grid.is_some() {
struct __With<'a>(&'a std::option::Option<f32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"percentageExportedToGrid",
&__With(&self.percentage_exported_to_grid),
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::SavingsOverTime {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.savings_year1.is_some() {
state.serialize_entry("savingsYear1", &self.savings_year1)?;
}
if self.savings_year20.is_some() {
state.serialize_entry("savingsYear20", &self.savings_year20)?;
}
if self.present_value_of_savings_year20.is_some() {
state.serialize_entry(
"presentValueOfSavingsYear20",
&self.present_value_of_savings_year20,
)?;
}
if self.savings_lifetime.is_some() {
state.serialize_entry("savingsLifetime", &self.savings_lifetime)?;
}
if self.present_value_of_savings_lifetime.is_some() {
state.serialize_entry(
"presentValueOfSavingsLifetime",
&self.present_value_of_savings_lifetime,
)?;
}
if !wkt::internal::is_default(&self.financially_viable) {
state.serialize_entry("financiallyViable", &self.financially_viable)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::LeasingSavings {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.leases_allowed) {
state.serialize_entry("leasesAllowed", &self.leases_allowed)?;
}
if !wkt::internal::is_default(&self.leases_supported) {
state.serialize_entry("leasesSupported", &self.leases_supported)?;
}
if self.annual_leasing_cost.is_some() {
state.serialize_entry("annualLeasingCost", &self.annual_leasing_cost)?;
}
if self.savings.is_some() {
state.serialize_entry("savings", &self.savings)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::CashPurchaseSavings {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.out_of_pocket_cost.is_some() {
state.serialize_entry("outOfPocketCost", &self.out_of_pocket_cost)?;
}
if self.upfront_cost.is_some() {
state.serialize_entry("upfrontCost", &self.upfront_cost)?;
}
if self.rebate_value.is_some() {
state.serialize_entry("rebateValue", &self.rebate_value)?;
}
if self.payback_years.is_some() {
struct __With<'a>(&'a std::option::Option<f32>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("paybackYears", &__With(&self.payback_years))?;
}
if self.savings.is_some() {
state.serialize_entry("savings", &self.savings)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::FinancedPurchaseSavings {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.annual_loan_payment.is_some() {
state.serialize_entry("annualLoanPayment", &self.annual_loan_payment)?;
}
if self.rebate_value.is_some() {
state.serialize_entry("rebateValue", &self.rebate_value)?;
}
if !wkt::internal::is_default(&self.loan_interest_rate) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry("loanInterestRate", &__With(&self.loan_interest_rate))?;
}
if self.savings.is_some() {
state.serialize_entry("savings", &self.savings)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetDataLayersRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.location.is_some() {
state.serialize_entry("location", &self.location)?;
}
if !wkt::internal::is_default(&self.radius_meters) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry("radiusMeters", &__With(&self.radius_meters))?;
}
if !wkt::internal::is_default(&self.view) {
state.serialize_entry("view", &self.view)?;
}
if !wkt::internal::is_default(&self.required_quality) {
state.serialize_entry("requiredQuality", &self.required_quality)?;
}
if !wkt::internal::is_default(&self.pixel_size_meters) {
struct __With<'a>(&'a f32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
}
}
state.serialize_entry("pixelSizeMeters", &__With(&self.pixel_size_meters))?;
}
if !wkt::internal::is_default(&self.exact_quality_required) {
state.serialize_entry("exactQualityRequired", &self.exact_quality_required)?;
}
if !self.experiments.is_empty() {
state.serialize_entry("experiments", &self.experiments)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DataLayers {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.imagery_date.is_some() {
state.serialize_entry("imageryDate", &self.imagery_date)?;
}
if self.imagery_processed_date.is_some() {
state.serialize_entry("imageryProcessedDate", &self.imagery_processed_date)?;
}
if !self.dsm_url.is_empty() {
state.serialize_entry("dsmUrl", &self.dsm_url)?;
}
if !self.rgb_url.is_empty() {
state.serialize_entry("rgbUrl", &self.rgb_url)?;
}
if !self.mask_url.is_empty() {
state.serialize_entry("maskUrl", &self.mask_url)?;
}
if !self.annual_flux_url.is_empty() {
state.serialize_entry("annualFluxUrl", &self.annual_flux_url)?;
}
if !self.monthly_flux_url.is_empty() {
state.serialize_entry("monthlyFluxUrl", &self.monthly_flux_url)?;
}
if !self.hourly_shade_urls.is_empty() {
state.serialize_entry("hourlyShadeUrls", &self.hourly_shade_urls)?;
}
if !wkt::internal::is_default(&self.imagery_quality) {
state.serialize_entry("imageryQuality", &self.imagery_quality)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetGeoTiffRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.id.is_empty() {
state.serialize_entry("id", &self.id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}