#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl serde::ser::Serialize for super::AirPressure {
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.mean_sea_level_millibars.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(
"meanSeaLevelMillibars",
&__With(&self.mean_sea_level_millibars),
)?;
}
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::SunEvents {
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.sunrise_time.is_some() {
state.serialize_entry("sunriseTime", &self.sunrise_time)?;
}
if self.sunset_time.is_some() {
state.serialize_entry("sunsetTime", &self.sunset_time)?;
}
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::MoonEvents {
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.moon_phase) {
state.serialize_entry("moonPhase", &self.moon_phase)?;
}
if !self.moonrise_times.is_empty() {
state.serialize_entry("moonriseTimes", &self.moonrise_times)?;
}
if !self.moonset_times.is_empty() {
state.serialize_entry("moonsetTimes", &self.moonset_times)?;
}
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::ForecastDay {
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.interval.is_some() {
state.serialize_entry("interval", &self.interval)?;
}
if self.display_date.is_some() {
state.serialize_entry("displayDate", &self.display_date)?;
}
if self.daytime_forecast.is_some() {
state.serialize_entry("daytimeForecast", &self.daytime_forecast)?;
}
if self.nighttime_forecast.is_some() {
state.serialize_entry("nighttimeForecast", &self.nighttime_forecast)?;
}
if self.max_temperature.is_some() {
state.serialize_entry("maxTemperature", &self.max_temperature)?;
}
if self.min_temperature.is_some() {
state.serialize_entry("minTemperature", &self.min_temperature)?;
}
if self.feels_like_max_temperature.is_some() {
state.serialize_entry("feelsLikeMaxTemperature", &self.feels_like_max_temperature)?;
}
if self.feels_like_min_temperature.is_some() {
state.serialize_entry("feelsLikeMinTemperature", &self.feels_like_min_temperature)?;
}
if self.sun_events.is_some() {
state.serialize_entry("sunEvents", &self.sun_events)?;
}
if self.moon_events.is_some() {
state.serialize_entry("moonEvents", &self.moon_events)?;
}
if self.max_heat_index.is_some() {
state.serialize_entry("maxHeatIndex", &self.max_heat_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::ForecastDayPart {
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.interval.is_some() {
state.serialize_entry("interval", &self.interval)?;
}
if self.weather_condition.is_some() {
state.serialize_entry("weatherCondition", &self.weather_condition)?;
}
if self.relative_humidity.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("relativeHumidity", &__With(&self.relative_humidity))?;
}
if self.uv_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("uvIndex", &__With(&self.uv_index))?;
}
if self.precipitation.is_some() {
state.serialize_entry("precipitation", &self.precipitation)?;
}
if self.thunderstorm_probability.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(
"thunderstormProbability",
&__With(&self.thunderstorm_probability),
)?;
}
if self.wind.is_some() {
state.serialize_entry("wind", &self.wind)?;
}
if self.cloud_cover.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("cloudCover", &__With(&self.cloud_cover))?;
}
if self.ice_thickness.is_some() {
state.serialize_entry("iceThickness", &self.ice_thickness)?;
}
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::ForecastHour {
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.interval.is_some() {
state.serialize_entry("interval", &self.interval)?;
}
if self.display_date_time.is_some() {
state.serialize_entry("displayDateTime", &self.display_date_time)?;
}
if self.is_daytime.is_some() {
state.serialize_entry("isDaytime", &self.is_daytime)?;
}
if self.weather_condition.is_some() {
state.serialize_entry("weatherCondition", &self.weather_condition)?;
}
if self.temperature.is_some() {
state.serialize_entry("temperature", &self.temperature)?;
}
if self.feels_like_temperature.is_some() {
state.serialize_entry("feelsLikeTemperature", &self.feels_like_temperature)?;
}
if self.dew_point.is_some() {
state.serialize_entry("dewPoint", &self.dew_point)?;
}
if self.heat_index.is_some() {
state.serialize_entry("heatIndex", &self.heat_index)?;
}
if self.wind_chill.is_some() {
state.serialize_entry("windChill", &self.wind_chill)?;
}
if self.wet_bulb_temperature.is_some() {
state.serialize_entry("wetBulbTemperature", &self.wet_bulb_temperature)?;
}
if self.relative_humidity.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("relativeHumidity", &__With(&self.relative_humidity))?;
}
if self.uv_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("uvIndex", &__With(&self.uv_index))?;
}
if self.precipitation.is_some() {
state.serialize_entry("precipitation", &self.precipitation)?;
}
if self.thunderstorm_probability.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(
"thunderstormProbability",
&__With(&self.thunderstorm_probability),
)?;
}
if self.air_pressure.is_some() {
state.serialize_entry("airPressure", &self.air_pressure)?;
}
if self.wind.is_some() {
state.serialize_entry("wind", &self.wind)?;
}
if self.visibility.is_some() {
state.serialize_entry("visibility", &self.visibility)?;
}
if self.cloud_cover.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("cloudCover", &__With(&self.cloud_cover))?;
}
if self.ice_thickness.is_some() {
state.serialize_entry("iceThickness", &self.ice_thickness)?;
}
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::PrecipitationSegment {
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.time_frame.is_some() {
state.serialize_entry("timeFrame", &self.time_frame)?;
}
if !wkt::internal::is_default(&self.r#type) {
state.serialize_entry("type", &self.r#type)?;
}
if !wkt::internal::is_default(&self.probability) {
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("probability", &__With(&self.probability))?;
}
if self.qpf.is_some() {
state.serialize_entry("qpf", &self.qpf)?;
}
if self.snowfall_amount.is_some() {
state.serialize_entry("snowfallAmount", &self.snowfall_amount)?;
}
if !wkt::internal::is_default(&self.intensity) {
state.serialize_entry("intensity", &self.intensity)?;
}
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::PrecipitationEvent {
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.title.is_empty() {
state.serialize_entry("title", &self.title)?;
}
if !self.subtitle.is_empty() {
state.serialize_entry("subtitle", &self.subtitle)?;
}
if self.time_frame.is_some() {
state.serialize_entry("timeFrame", &self.time_frame)?;
}
if !self.intervals.is_empty() {
state.serialize_entry("intervals", &self.intervals)?;
}
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::PrecipitationsInterval {
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.time_frame.is_some() {
state.serialize_entry("timeFrame", &self.time_frame)?;
}
if !wkt::internal::is_default(&self.r#type) {
state.serialize_entry("type", &self.r#type)?;
}
if !wkt::internal::is_default(&self.probability) {
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("probability", &__With(&self.probability))?;
}
if self.qpf.is_some() {
state.serialize_entry("qpf", &self.qpf)?;
}
if self.snow_qpf.is_some() {
state.serialize_entry("snowQpf", &self.snow_qpf)?;
}
if !wkt::internal::is_default(&self.intensity) {
state.serialize_entry("intensity", &self.intensity)?;
}
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::HistoryHour {
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.interval.is_some() {
state.serialize_entry("interval", &self.interval)?;
}
if self.display_date_time.is_some() {
state.serialize_entry("displayDateTime", &self.display_date_time)?;
}
if self.is_daytime.is_some() {
state.serialize_entry("isDaytime", &self.is_daytime)?;
}
if self.weather_condition.is_some() {
state.serialize_entry("weatherCondition", &self.weather_condition)?;
}
if self.temperature.is_some() {
state.serialize_entry("temperature", &self.temperature)?;
}
if self.feels_like_temperature.is_some() {
state.serialize_entry("feelsLikeTemperature", &self.feels_like_temperature)?;
}
if self.dew_point.is_some() {
state.serialize_entry("dewPoint", &self.dew_point)?;
}
if self.heat_index.is_some() {
state.serialize_entry("heatIndex", &self.heat_index)?;
}
if self.wind_chill.is_some() {
state.serialize_entry("windChill", &self.wind_chill)?;
}
if self.wet_bulb_temperature.is_some() {
state.serialize_entry("wetBulbTemperature", &self.wet_bulb_temperature)?;
}
if self.relative_humidity.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("relativeHumidity", &__With(&self.relative_humidity))?;
}
if self.uv_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("uvIndex", &__With(&self.uv_index))?;
}
if self.precipitation.is_some() {
state.serialize_entry("precipitation", &self.precipitation)?;
}
if self.thunderstorm_probability.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(
"thunderstormProbability",
&__With(&self.thunderstorm_probability),
)?;
}
if self.air_pressure.is_some() {
state.serialize_entry("airPressure", &self.air_pressure)?;
}
if self.wind.is_some() {
state.serialize_entry("wind", &self.wind)?;
}
if self.visibility.is_some() {
state.serialize_entry("visibility", &self.visibility)?;
}
if self.cloud_cover.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("cloudCover", &__With(&self.cloud_cover))?;
}
if self.ice_thickness.is_some() {
state.serialize_entry("iceThickness", &self.ice_thickness)?;
}
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::IceThickness {
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.thickness.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("thickness", &__With(&self.thickness))?;
}
if !wkt::internal::is_default(&self.unit) {
state.serialize_entry("unit", &self.unit)?;
}
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::Precipitation {
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.probability.is_some() {
state.serialize_entry("probability", &self.probability)?;
}
if self.snow_qpf.is_some() {
state.serialize_entry("snowQpf", &self.snow_qpf)?;
}
if self.qpf.is_some() {
state.serialize_entry("qpf", &self.qpf)?;
}
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::PrecipitationProbability {
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.percent.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("percent", &__With(&self.percent))?;
}
if !wkt::internal::is_default(&self.r#type) {
state.serialize_entry("type", &self.r#type)?;
}
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::QuantitativePrecipitationForecast {
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.quantity.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("quantity", &__With(&self.quantity))?;
}
if !wkt::internal::is_default(&self.unit) {
state.serialize_entry("unit", &self.unit)?;
}
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::DataSource {
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.publisher) {
state.serialize_entry("publisher", &self.publisher)?;
}
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if !self.authority_uri.is_empty() {
state.serialize_entry("authorityUri", &self.authority_uri)?;
}
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::SafetyRecommendation {
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.directive.is_empty() {
state.serialize_entry("directive", &self.directive)?;
}
if self.subtext.is_some() {
state.serialize_entry("subtext", &self.subtext)?;
}
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::PublicAlerts {
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.alert_id.is_empty() {
state.serialize_entry("alertId", &self.alert_id)?;
}
if self.alert_title.is_some() {
state.serialize_entry("alertTitle", &self.alert_title)?;
}
if !wkt::internal::is_default(&self.event_type) {
state.serialize_entry("eventType", &self.event_type)?;
}
if !self.area_name.is_empty() {
state.serialize_entry("areaName", &self.area_name)?;
}
if self.polygon.is_some() {
state.serialize_entry("polygon", &self.polygon)?;
}
if self.description.is_some() {
state.serialize_entry("description", &self.description)?;
}
if self.severity.is_some() {
state.serialize_entry("severity", &self.severity)?;
}
if self.certainty.is_some() {
state.serialize_entry("certainty", &self.certainty)?;
}
if self.urgency.is_some() {
state.serialize_entry("urgency", &self.urgency)?;
}
if !self.instruction.is_empty() {
state.serialize_entry("instruction", &self.instruction)?;
}
if !self.safety_recommendations.is_empty() {
state.serialize_entry("safetyRecommendations", &self.safety_recommendations)?;
}
if !self.timezone_offset.is_empty() {
state.serialize_entry("timezoneOffset", &self.timezone_offset)?;
}
if self.start_time.is_some() {
state.serialize_entry("startTime", &self.start_time)?;
}
if self.expiration_time.is_some() {
state.serialize_entry("expirationTime", &self.expiration_time)?;
}
if self.data_source.is_some() {
state.serialize_entry("dataSource", &self.data_source)?;
}
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::Temperature {
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.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("degrees", &__With(&self.degrees))?;
}
if !wkt::internal::is_default(&self.unit) {
state.serialize_entry("unit", &self.unit)?;
}
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::Visibility {
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.distance.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("distance", &__With(&self.distance))?;
}
if !wkt::internal::is_default(&self.unit) {
state.serialize_entry("unit", &self.unit)?;
}
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::WeatherCondition {
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.icon_base_uri.is_empty() {
state.serialize_entry("iconBaseUri", &self.icon_base_uri)?;
}
if self.description.is_some() {
state.serialize_entry("description", &self.description)?;
}
if !wkt::internal::is_default(&self.r#type) {
state.serialize_entry("type", &self.r#type)?;
}
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::LookupCurrentConditionsRequest {
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.units_system) {
state.serialize_entry("unitsSystem", &self.units_system)?;
}
if self.language_code.is_some() {
state.serialize_entry("languageCode", &self.language_code)?;
}
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::LookupCurrentConditionsResponse {
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.current_time.is_some() {
state.serialize_entry("currentTime", &self.current_time)?;
}
if self.time_zone.is_some() {
state.serialize_entry("timeZone", &self.time_zone)?;
}
if self.is_daytime.is_some() {
state.serialize_entry("isDaytime", &self.is_daytime)?;
}
if self.weather_condition.is_some() {
state.serialize_entry("weatherCondition", &self.weather_condition)?;
}
if self.temperature.is_some() {
state.serialize_entry("temperature", &self.temperature)?;
}
if self.feels_like_temperature.is_some() {
state.serialize_entry("feelsLikeTemperature", &self.feels_like_temperature)?;
}
if self.dew_point.is_some() {
state.serialize_entry("dewPoint", &self.dew_point)?;
}
if self.heat_index.is_some() {
state.serialize_entry("heatIndex", &self.heat_index)?;
}
if self.wind_chill.is_some() {
state.serialize_entry("windChill", &self.wind_chill)?;
}
if self.relative_humidity.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("relativeHumidity", &__With(&self.relative_humidity))?;
}
if self.uv_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("uvIndex", &__With(&self.uv_index))?;
}
if self.precipitation.is_some() {
state.serialize_entry("precipitation", &self.precipitation)?;
}
if self.thunderstorm_probability.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(
"thunderstormProbability",
&__With(&self.thunderstorm_probability),
)?;
}
if self.air_pressure.is_some() {
state.serialize_entry("airPressure", &self.air_pressure)?;
}
if self.wind.is_some() {
state.serialize_entry("wind", &self.wind)?;
}
if self.visibility.is_some() {
state.serialize_entry("visibility", &self.visibility)?;
}
if self.cloud_cover.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("cloudCover", &__With(&self.cloud_cover))?;
}
if self.current_conditions_history.is_some() {
state.serialize_entry("currentConditionsHistory", &self.current_conditions_history)?;
}
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::lookup_current_conditions_response::CurrentConditionsHistory {
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.temperature_change.is_some() {
state.serialize_entry("temperatureChange", &self.temperature_change)?;
}
if self.max_temperature.is_some() {
state.serialize_entry("maxTemperature", &self.max_temperature)?;
}
if self.min_temperature.is_some() {
state.serialize_entry("minTemperature", &self.min_temperature)?;
}
if self.snow_qpf.is_some() {
state.serialize_entry("snowQpf", &self.snow_qpf)?;
}
if self.qpf.is_some() {
state.serialize_entry("qpf", &self.qpf)?;
}
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::LookupForecastHoursRequest {
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 self.hours.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("hours", &__With(&self.hours))?;
}
if !wkt::internal::is_default(&self.units_system) {
state.serialize_entry("unitsSystem", &self.units_system)?;
}
if self.language_code.is_some() {
state.serialize_entry("languageCode", &self.language_code)?;
}
if !wkt::internal::is_default(&self.page_size) {
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("pageSize", &__With(&self.page_size))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
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::LookupForecastHoursResponse {
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.forecast_hours.is_empty() {
state.serialize_entry("forecastHours", &self.forecast_hours)?;
}
if self.time_zone.is_some() {
state.serialize_entry("timeZone", &self.time_zone)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
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::LookupForecastDaysRequest {
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 self.days.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("days", &__With(&self.days))?;
}
if !wkt::internal::is_default(&self.units_system) {
state.serialize_entry("unitsSystem", &self.units_system)?;
}
if self.language_code.is_some() {
state.serialize_entry("languageCode", &self.language_code)?;
}
if !wkt::internal::is_default(&self.page_size) {
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("pageSize", &__With(&self.page_size))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
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::LookupForecastDaysResponse {
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.forecast_days.is_empty() {
state.serialize_entry("forecastDays", &self.forecast_days)?;
}
if self.time_zone.is_some() {
state.serialize_entry("timeZone", &self.time_zone)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
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::LookupHistoryHoursRequest {
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 self.hours.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("hours", &__With(&self.hours))?;
}
if !wkt::internal::is_default(&self.units_system) {
state.serialize_entry("unitsSystem", &self.units_system)?;
}
if self.language_code.is_some() {
state.serialize_entry("languageCode", &self.language_code)?;
}
if !wkt::internal::is_default(&self.page_size) {
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("pageSize", &__With(&self.page_size))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
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::LookupHistoryHoursResponse {
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.history_hours.is_empty() {
state.serialize_entry("historyHours", &self.history_hours)?;
}
if self.time_zone.is_some() {
state.serialize_entry("timeZone", &self.time_zone)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
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::LookupPublicAlertsRequest {
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 self.language_code.is_some() {
state.serialize_entry("languageCode", &self.language_code)?;
}
if !wkt::internal::is_default(&self.page_size) {
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("pageSize", &__With(&self.page_size))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
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::LookupPublicAlertsResponse {
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.weather_alerts.is_empty() {
state.serialize_entry("weatherAlerts", &self.weather_alerts)?;
}
if !self.region_code.is_empty() {
state.serialize_entry("regionCode", &self.region_code)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
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::LookupForecastMinutesRequest {
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.units_system) {
state.serialize_entry("unitsSystem", &self.units_system)?;
}
if !wkt::internal::is_default(&self.page_size) {
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("pageSize", &__With(&self.page_size))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
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::LookupForecastMinutesResponse {
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.overall_prediction_timeframe.is_some() {
state.serialize_entry(
"overallPredictionTimeframe",
&self.overall_prediction_timeframe,
)?;
}
if self.time_zone.is_some() {
state.serialize_entry("timeZone", &self.time_zone)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
if !self.segments.is_empty() {
state.serialize_entry("segments", &self.segments)?;
}
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::LookupMapTileRequest {
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.map_type) {
state.serialize_entry("mapType", &self.map_type)?;
}
if !wkt::internal::is_default(&self.zoom) {
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("zoom", &__With(&self.zoom))?;
}
if !wkt::internal::is_default(&self.x) {
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("x", &__With(&self.x))?;
}
if !wkt::internal::is_default(&self.y) {
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("y", &__With(&self.y))?;
}
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::Wind {
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.direction.is_some() {
state.serialize_entry("direction", &self.direction)?;
}
if self.speed.is_some() {
state.serialize_entry("speed", &self.speed)?;
}
if self.gust.is_some() {
state.serialize_entry("gust", &self.gust)?;
}
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::WindDirection {
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.degrees.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("degrees", &__With(&self.degrees))?;
}
if !wkt::internal::is_default(&self.cardinal) {
state.serialize_entry("cardinal", &self.cardinal)?;
}
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::WindSpeed {
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.value.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("value", &__With(&self.value))?;
}
if !wkt::internal::is_default(&self.unit) {
state.serialize_entry("unit", &self.unit)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}