google-maps-places-v1 1.0.0

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#[allow(unused_imports)]
use super::*;

#[doc(hidden)]
impl serde::ser::Serialize for super::AddressDescriptor {
    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.landmarks.is_empty() {
            state.serialize_entry("landmarks", &self.landmarks)?;
        }
        if !self.areas.is_empty() {
            state.serialize_entry("areas", &self.areas)?;
        }
        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::address_descriptor::Landmark {
    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.place_id.is_empty() {
            state.serialize_entry("placeId", &self.place_id)?;
        }
        if self.display_name.is_some() {
            state.serialize_entry("displayName", &self.display_name)?;
        }
        if !self.types.is_empty() {
            state.serialize_entry("types", &self.types)?;
        }
        if !wkt::internal::is_default(&self.spatial_relationship) {
            state.serialize_entry("spatialRelationship", &self.spatial_relationship)?;
        }
        if !wkt::internal::is_default(&self.straight_line_distance_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(
                "straightLineDistanceMeters",
                &__With(&self.straight_line_distance_meters),
            )?;
        }
        if self.travel_distance_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(
                "travelDistanceMeters",
                &__With(&self.travel_distance_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::address_descriptor::Area {
    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.place_id.is_empty() {
            state.serialize_entry("placeId", &self.place_id)?;
        }
        if self.display_name.is_some() {
            state.serialize_entry("displayName", &self.display_name)?;
        }
        if !wkt::internal::is_default(&self.containment) {
            state.serialize_entry("containment", &self.containment)?;
        }
        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::AuthorAttribution {
    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.display_name.is_empty() {
            state.serialize_entry("displayName", &self.display_name)?;
        }
        if !self.uri.is_empty() {
            state.serialize_entry("uri", &self.uri)?;
        }
        if !self.photo_uri.is_empty() {
            state.serialize_entry("photoUri", &self.photo_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::ContentBlock {
    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.content.is_some() {
            state.serialize_entry("content", &self.content)?;
        }
        if !self.referenced_places.is_empty() {
            state.serialize_entry("referencedPlaces", &self.referenced_places)?;
        }
        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::ContextualContent {
    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.reviews.is_empty() {
            state.serialize_entry("reviews", &self.reviews)?;
        }
        if !self.photos.is_empty() {
            state.serialize_entry("photos", &self.photos)?;
        }
        if !self.justifications.is_empty() {
            state.serialize_entry("justifications", &self.justifications)?;
        }
        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::contextual_content::Justification {
    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 let Some(value) = self.review_justification() {
            state.serialize_entry("reviewJustification", value)?;
        }
        if let Some(value) = self.business_availability_attributes_justification() {
            state.serialize_entry("businessAvailabilityAttributesJustification", value)?;
        }
        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::contextual_content::justification::ReviewJustification {
    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.highlighted_text.is_some() {
            state.serialize_entry("highlightedText", &self.highlighted_text)?;
        }
        if self.review.is_some() {
            state.serialize_entry("review", &self.review)?;
        }
        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::contextual_content::justification::review_justification::HighlightedText
{
    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.text.is_empty() {
            state.serialize_entry("text", &self.text)?;
        }
        if !self.highlighted_text_ranges.is_empty() {
            state.serialize_entry("highlightedTextRanges", &self.highlighted_text_ranges)?;
        }
        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::contextual_content::justification::review_justification::highlighted_text::HighlightedTextRange {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        #[allow(unused_imports)]
        use std::option::Option::Some;
        use serde::ser::SerializeMap;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.start_index) {
            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("startIndex", &__With(&self.start_index))?;
        }
        if !wkt::internal::is_default(&self.end_index) {
            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("endIndex", &__With(&self.end_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::contextual_content::justification::BusinessAvailabilityAttributesJustification
{
    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.takeout) {
            state.serialize_entry("takeout", &self.takeout)?;
        }
        if !wkt::internal::is_default(&self.delivery) {
            state.serialize_entry("delivery", &self.delivery)?;
        }
        if !wkt::internal::is_default(&self.dine_in) {
            state.serialize_entry("dineIn", &self.dine_in)?;
        }
        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::EVChargeOptions {
    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.connector_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("connectorCount", &__With(&self.connector_count))?;
        }
        if !self.connector_aggregation.is_empty() {
            state.serialize_entry("connectorAggregation", &self.connector_aggregation)?;
        }
        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::ev_charge_options::ConnectorAggregation {
    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.r#type) {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !wkt::internal::is_default(&self.max_charge_rate_kw) {
            struct __With<'a>(&'a f64);
            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::F64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("maxChargeRateKw", &__With(&self.max_charge_rate_kw))?;
        }
        if !wkt::internal::is_default(&self.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("count", &__With(&self.count))?;
        }
        if self.available_count.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("availableCount", &__With(&self.available_count))?;
        }
        if self.out_of_service_count.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("outOfServiceCount", &__With(&self.out_of_service_count))?;
        }
        if self.availability_last_update_time.is_some() {
            state.serialize_entry(
                "availabilityLastUpdateTime",
                &self.availability_last_update_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::FuelOptions {
    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.fuel_prices.is_empty() {
            state.serialize_entry("fuelPrices", &self.fuel_prices)?;
        }
        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::fuel_options::FuelPrice {
    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.r#type) {
            state.serialize_entry("type", &self.r#type)?;
        }
        if self.price.is_some() {
            state.serialize_entry("price", &self.price)?;
        }
        if self.update_time.is_some() {
            state.serialize_entry("updateTime", &self.update_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::Circle {
    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.radius) {
            struct __With<'a>(&'a f64);
            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::F64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("radius", &__With(&self.radius))?;
        }
        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::Photo {
    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 !wkt::internal::is_default(&self.width_px) {
            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("widthPx", &__With(&self.width_px))?;
        }
        if !wkt::internal::is_default(&self.height_px) {
            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("heightPx", &__With(&self.height_px))?;
        }
        if !self.author_attributions.is_empty() {
            state.serialize_entry("authorAttributions", &self.author_attributions)?;
        }
        if !self.flag_content_uri.is_empty() {
            state.serialize_entry("flagContentUri", &self.flag_content_uri)?;
        }
        if !self.google_maps_uri.is_empty() {
            state.serialize_entry("googleMapsUri", &self.google_maps_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::Place {
    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.id.is_empty() {
            state.serialize_entry("id", &self.id)?;
        }
        if self.display_name.is_some() {
            state.serialize_entry("displayName", &self.display_name)?;
        }
        if !self.types.is_empty() {
            state.serialize_entry("types", &self.types)?;
        }
        if !self.primary_type.is_empty() {
            state.serialize_entry("primaryType", &self.primary_type)?;
        }
        if self.primary_type_display_name.is_some() {
            state.serialize_entry("primaryTypeDisplayName", &self.primary_type_display_name)?;
        }
        if self.google_maps_type_label.is_some() {
            state.serialize_entry("googleMapsTypeLabel", &self.google_maps_type_label)?;
        }
        if !self.national_phone_number.is_empty() {
            state.serialize_entry("nationalPhoneNumber", &self.national_phone_number)?;
        }
        if !self.international_phone_number.is_empty() {
            state.serialize_entry("internationalPhoneNumber", &self.international_phone_number)?;
        }
        if !self.formatted_address.is_empty() {
            state.serialize_entry("formattedAddress", &self.formatted_address)?;
        }
        if !self.short_formatted_address.is_empty() {
            state.serialize_entry("shortFormattedAddress", &self.short_formatted_address)?;
        }
        if self.postal_address.is_some() {
            state.serialize_entry("postalAddress", &self.postal_address)?;
        }
        if !self.address_components.is_empty() {
            state.serialize_entry("addressComponents", &self.address_components)?;
        }
        if self.plus_code.is_some() {
            state.serialize_entry("plusCode", &self.plus_code)?;
        }
        if self.location.is_some() {
            state.serialize_entry("location", &self.location)?;
        }
        if self.viewport.is_some() {
            state.serialize_entry("viewport", &self.viewport)?;
        }
        if !wkt::internal::is_default(&self.rating) {
            struct __With<'a>(&'a f64);
            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::F64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("rating", &__With(&self.rating))?;
        }
        if !self.google_maps_uri.is_empty() {
            state.serialize_entry("googleMapsUri", &self.google_maps_uri)?;
        }
        if !self.website_uri.is_empty() {
            state.serialize_entry("websiteUri", &self.website_uri)?;
        }
        if !self.reviews.is_empty() {
            state.serialize_entry("reviews", &self.reviews)?;
        }
        if self.regular_opening_hours.is_some() {
            state.serialize_entry("regularOpeningHours", &self.regular_opening_hours)?;
        }
        if self.utc_offset_minutes.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("utcOffsetMinutes", &__With(&self.utc_offset_minutes))?;
        }
        if self.time_zone.is_some() {
            state.serialize_entry("timeZone", &self.time_zone)?;
        }
        if !self.photos.is_empty() {
            state.serialize_entry("photos", &self.photos)?;
        }
        if !self.adr_format_address.is_empty() {
            state.serialize_entry("adrFormatAddress", &self.adr_format_address)?;
        }
        if !wkt::internal::is_default(&self.business_status) {
            state.serialize_entry("businessStatus", &self.business_status)?;
        }
        if self.opening_date.is_some() {
            state.serialize_entry("openingDate", &self.opening_date)?;
        }
        if !wkt::internal::is_default(&self.price_level) {
            state.serialize_entry("priceLevel", &self.price_level)?;
        }
        if !self.attributions.is_empty() {
            state.serialize_entry("attributions", &self.attributions)?;
        }
        if self.user_rating_count.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("userRatingCount", &__With(&self.user_rating_count))?;
        }
        if !self.icon_mask_base_uri.is_empty() {
            state.serialize_entry("iconMaskBaseUri", &self.icon_mask_base_uri)?;
        }
        if !self.icon_background_color.is_empty() {
            state.serialize_entry("iconBackgroundColor", &self.icon_background_color)?;
        }
        if self.takeout.is_some() {
            state.serialize_entry("takeout", &self.takeout)?;
        }
        if self.delivery.is_some() {
            state.serialize_entry("delivery", &self.delivery)?;
        }
        if self.dine_in.is_some() {
            state.serialize_entry("dineIn", &self.dine_in)?;
        }
        if self.curbside_pickup.is_some() {
            state.serialize_entry("curbsidePickup", &self.curbside_pickup)?;
        }
        if self.reservable.is_some() {
            state.serialize_entry("reservable", &self.reservable)?;
        }
        if self.serves_breakfast.is_some() {
            state.serialize_entry("servesBreakfast", &self.serves_breakfast)?;
        }
        if self.serves_lunch.is_some() {
            state.serialize_entry("servesLunch", &self.serves_lunch)?;
        }
        if self.serves_dinner.is_some() {
            state.serialize_entry("servesDinner", &self.serves_dinner)?;
        }
        if self.serves_beer.is_some() {
            state.serialize_entry("servesBeer", &self.serves_beer)?;
        }
        if self.serves_wine.is_some() {
            state.serialize_entry("servesWine", &self.serves_wine)?;
        }
        if self.serves_brunch.is_some() {
            state.serialize_entry("servesBrunch", &self.serves_brunch)?;
        }
        if self.serves_vegetarian_food.is_some() {
            state.serialize_entry("servesVegetarianFood", &self.serves_vegetarian_food)?;
        }
        if self.current_opening_hours.is_some() {
            state.serialize_entry("currentOpeningHours", &self.current_opening_hours)?;
        }
        if !self.current_secondary_opening_hours.is_empty() {
            state.serialize_entry(
                "currentSecondaryOpeningHours",
                &self.current_secondary_opening_hours,
            )?;
        }
        if !self.regular_secondary_opening_hours.is_empty() {
            state.serialize_entry(
                "regularSecondaryOpeningHours",
                &self.regular_secondary_opening_hours,
            )?;
        }
        if self.editorial_summary.is_some() {
            state.serialize_entry("editorialSummary", &self.editorial_summary)?;
        }
        if self.outdoor_seating.is_some() {
            state.serialize_entry("outdoorSeating", &self.outdoor_seating)?;
        }
        if self.live_music.is_some() {
            state.serialize_entry("liveMusic", &self.live_music)?;
        }
        if self.menu_for_children.is_some() {
            state.serialize_entry("menuForChildren", &self.menu_for_children)?;
        }
        if self.serves_cocktails.is_some() {
            state.serialize_entry("servesCocktails", &self.serves_cocktails)?;
        }
        if self.serves_dessert.is_some() {
            state.serialize_entry("servesDessert", &self.serves_dessert)?;
        }
        if self.serves_coffee.is_some() {
            state.serialize_entry("servesCoffee", &self.serves_coffee)?;
        }
        if self.good_for_children.is_some() {
            state.serialize_entry("goodForChildren", &self.good_for_children)?;
        }
        if self.allows_dogs.is_some() {
            state.serialize_entry("allowsDogs", &self.allows_dogs)?;
        }
        if self.restroom.is_some() {
            state.serialize_entry("restroom", &self.restroom)?;
        }
        if self.good_for_groups.is_some() {
            state.serialize_entry("goodForGroups", &self.good_for_groups)?;
        }
        if self.good_for_watching_sports.is_some() {
            state.serialize_entry("goodForWatchingSports", &self.good_for_watching_sports)?;
        }
        if self.payment_options.is_some() {
            state.serialize_entry("paymentOptions", &self.payment_options)?;
        }
        if self.parking_options.is_some() {
            state.serialize_entry("parkingOptions", &self.parking_options)?;
        }
        if !self.sub_destinations.is_empty() {
            state.serialize_entry("subDestinations", &self.sub_destinations)?;
        }
        if self.accessibility_options.is_some() {
            state.serialize_entry("accessibilityOptions", &self.accessibility_options)?;
        }
        if self.fuel_options.is_some() {
            state.serialize_entry("fuelOptions", &self.fuel_options)?;
        }
        if self.ev_charge_options.is_some() {
            state.serialize_entry("evChargeOptions", &self.ev_charge_options)?;
        }
        if self.generative_summary.is_some() {
            state.serialize_entry("generativeSummary", &self.generative_summary)?;
        }
        if !self.containing_places.is_empty() {
            state.serialize_entry("containingPlaces", &self.containing_places)?;
        }
        if self.pure_service_area_business.is_some() {
            state.serialize_entry("pureServiceAreaBusiness", &self.pure_service_area_business)?;
        }
        if self.address_descriptor.is_some() {
            state.serialize_entry("addressDescriptor", &self.address_descriptor)?;
        }
        if self.google_maps_links.is_some() {
            state.serialize_entry("googleMapsLinks", &self.google_maps_links)?;
        }
        if self.price_range.is_some() {
            state.serialize_entry("priceRange", &self.price_range)?;
        }
        if self.review_summary.is_some() {
            state.serialize_entry("reviewSummary", &self.review_summary)?;
        }
        if self.ev_charge_amenity_summary.is_some() {
            state.serialize_entry("evChargeAmenitySummary", &self.ev_charge_amenity_summary)?;
        }
        if self.neighborhood_summary.is_some() {
            state.serialize_entry("neighborhoodSummary", &self.neighborhood_summary)?;
        }
        if self.consumer_alert.is_some() {
            state.serialize_entry("consumerAlert", &self.consumer_alert)?;
        }
        if !self.moved_place.is_empty() {
            state.serialize_entry("movedPlace", &self.moved_place)?;
        }
        if !self.moved_place_id.is_empty() {
            state.serialize_entry("movedPlaceId", &self.moved_place_id)?;
        }
        if self.transit_station.is_some() {
            state.serialize_entry("transitStation", &self.transit_station)?;
        }
        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::place::AddressComponent {
    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.long_text.is_empty() {
            state.serialize_entry("longText", &self.long_text)?;
        }
        if !self.short_text.is_empty() {
            state.serialize_entry("shortText", &self.short_text)?;
        }
        if !self.types.is_empty() {
            state.serialize_entry("types", &self.types)?;
        }
        if !self.language_code.is_empty() {
            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::place::PlusCode {
    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.global_code.is_empty() {
            state.serialize_entry("globalCode", &self.global_code)?;
        }
        if !self.compound_code.is_empty() {
            state.serialize_entry("compoundCode", &self.compound_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::place::OpeningHours {
    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.open_now.is_some() {
            state.serialize_entry("openNow", &self.open_now)?;
        }
        if !self.periods.is_empty() {
            state.serialize_entry("periods", &self.periods)?;
        }
        if !self.weekday_descriptions.is_empty() {
            state.serialize_entry("weekdayDescriptions", &self.weekday_descriptions)?;
        }
        if !wkt::internal::is_default(&self.secondary_hours_type) {
            state.serialize_entry("secondaryHoursType", &self.secondary_hours_type)?;
        }
        if !self.special_days.is_empty() {
            state.serialize_entry("specialDays", &self.special_days)?;
        }
        if self.next_open_time.is_some() {
            state.serialize_entry("nextOpenTime", &self.next_open_time)?;
        }
        if self.next_close_time.is_some() {
            state.serialize_entry("nextCloseTime", &self.next_close_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::place::opening_hours::Period {
    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.open.is_some() {
            state.serialize_entry("open", &self.open)?;
        }
        if self.close.is_some() {
            state.serialize_entry("close", &self.close)?;
        }
        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::place::opening_hours::period::Point {
    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.day.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("day", &__With(&self.day))?;
        }
        if self.hour.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("hour", &__With(&self.hour))?;
        }
        if self.minute.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("minute", &__With(&self.minute))?;
        }
        if self.date.is_some() {
            state.serialize_entry("date", &self.date)?;
        }
        if !wkt::internal::is_default(&self.truncated) {
            state.serialize_entry("truncated", &self.truncated)?;
        }
        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::place::opening_hours::SpecialDay {
    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.date.is_some() {
            state.serialize_entry("date", &self.date)?;
        }
        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::place::Attribution {
    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.provider.is_empty() {
            state.serialize_entry("provider", &self.provider)?;
        }
        if !self.provider_uri.is_empty() {
            state.serialize_entry("providerUri", &self.provider_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::place::PaymentOptions {
    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.accepts_credit_cards.is_some() {
            state.serialize_entry("acceptsCreditCards", &self.accepts_credit_cards)?;
        }
        if self.accepts_debit_cards.is_some() {
            state.serialize_entry("acceptsDebitCards", &self.accepts_debit_cards)?;
        }
        if self.accepts_cash_only.is_some() {
            state.serialize_entry("acceptsCashOnly", &self.accepts_cash_only)?;
        }
        if self.accepts_nfc.is_some() {
            state.serialize_entry("acceptsNfc", &self.accepts_nfc)?;
        }
        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::place::ParkingOptions {
    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.free_parking_lot.is_some() {
            state.serialize_entry("freeParkingLot", &self.free_parking_lot)?;
        }
        if self.paid_parking_lot.is_some() {
            state.serialize_entry("paidParkingLot", &self.paid_parking_lot)?;
        }
        if self.free_street_parking.is_some() {
            state.serialize_entry("freeStreetParking", &self.free_street_parking)?;
        }
        if self.paid_street_parking.is_some() {
            state.serialize_entry("paidStreetParking", &self.paid_street_parking)?;
        }
        if self.valet_parking.is_some() {
            state.serialize_entry("valetParking", &self.valet_parking)?;
        }
        if self.free_garage_parking.is_some() {
            state.serialize_entry("freeGarageParking", &self.free_garage_parking)?;
        }
        if self.paid_garage_parking.is_some() {
            state.serialize_entry("paidGarageParking", &self.paid_garage_parking)?;
        }
        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::place::SubDestination {
    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.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()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::place::AccessibilityOptions {
    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.wheelchair_accessible_parking.is_some() {
            state.serialize_entry(
                "wheelchairAccessibleParking",
                &self.wheelchair_accessible_parking,
            )?;
        }
        if self.wheelchair_accessible_entrance.is_some() {
            state.serialize_entry(
                "wheelchairAccessibleEntrance",
                &self.wheelchair_accessible_entrance,
            )?;
        }
        if self.wheelchair_accessible_restroom.is_some() {
            state.serialize_entry(
                "wheelchairAccessibleRestroom",
                &self.wheelchair_accessible_restroom,
            )?;
        }
        if self.wheelchair_accessible_seating.is_some() {
            state.serialize_entry(
                "wheelchairAccessibleSeating",
                &self.wheelchair_accessible_seating,
            )?;
        }
        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::place::GenerativeSummary {
    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.overview.is_some() {
            state.serialize_entry("overview", &self.overview)?;
        }
        if !self.overview_flag_content_uri.is_empty() {
            state.serialize_entry("overviewFlagContentUri", &self.overview_flag_content_uri)?;
        }
        if self.disclosure_text.is_some() {
            state.serialize_entry("disclosureText", &self.disclosure_text)?;
        }
        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::place::ContainingPlace {
    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.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()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::place::GoogleMapsLinks {
    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.directions_uri.is_empty() {
            state.serialize_entry("directionsUri", &self.directions_uri)?;
        }
        if !self.place_uri.is_empty() {
            state.serialize_entry("placeUri", &self.place_uri)?;
        }
        if !self.write_a_review_uri.is_empty() {
            state.serialize_entry("writeAReviewUri", &self.write_a_review_uri)?;
        }
        if !self.reviews_uri.is_empty() {
            state.serialize_entry("reviewsUri", &self.reviews_uri)?;
        }
        if !self.photos_uri.is_empty() {
            state.serialize_entry("photosUri", &self.photos_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::place::ReviewSummary {
    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.text.is_some() {
            state.serialize_entry("text", &self.text)?;
        }
        if !self.flag_content_uri.is_empty() {
            state.serialize_entry("flagContentUri", &self.flag_content_uri)?;
        }
        if self.disclosure_text.is_some() {
            state.serialize_entry("disclosureText", &self.disclosure_text)?;
        }
        if !self.reviews_uri.is_empty() {
            state.serialize_entry("reviewsUri", &self.reviews_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::place::EvChargeAmenitySummary {
    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.overview.is_some() {
            state.serialize_entry("overview", &self.overview)?;
        }
        if self.coffee.is_some() {
            state.serialize_entry("coffee", &self.coffee)?;
        }
        if self.restaurant.is_some() {
            state.serialize_entry("restaurant", &self.restaurant)?;
        }
        if self.store.is_some() {
            state.serialize_entry("store", &self.store)?;
        }
        if !self.flag_content_uri.is_empty() {
            state.serialize_entry("flagContentUri", &self.flag_content_uri)?;
        }
        if self.disclosure_text.is_some() {
            state.serialize_entry("disclosureText", &self.disclosure_text)?;
        }
        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::place::NeighborhoodSummary {
    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.overview.is_some() {
            state.serialize_entry("overview", &self.overview)?;
        }
        if self.description.is_some() {
            state.serialize_entry("description", &self.description)?;
        }
        if !self.flag_content_uri.is_empty() {
            state.serialize_entry("flagContentUri", &self.flag_content_uri)?;
        }
        if self.disclosure_text.is_some() {
            state.serialize_entry("disclosureText", &self.disclosure_text)?;
        }
        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::place::ConsumerAlert {
    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.overview.is_empty() {
            state.serialize_entry("overview", &self.overview)?;
        }
        if self.details.is_some() {
            state.serialize_entry("details", &self.details)?;
        }
        if !self.language_code.is_empty() {
            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::place::consumer_alert::Details {
    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.description.is_empty() {
            state.serialize_entry("description", &self.description)?;
        }
        if self.about_link.is_some() {
            state.serialize_entry("aboutLink", &self.about_link)?;
        }
        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::place::consumer_alert::details::Link {
    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.uri.is_empty() {
            state.serialize_entry("uri", &self.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::RoutingParameters {
    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.origin.is_some() {
            state.serialize_entry("origin", &self.origin)?;
        }
        if !wkt::internal::is_default(&self.travel_mode) {
            state.serialize_entry("travelMode", &self.travel_mode)?;
        }
        if self.route_modifiers.is_some() {
            state.serialize_entry("routeModifiers", &self.route_modifiers)?;
        }
        if !wkt::internal::is_default(&self.routing_preference) {
            state.serialize_entry("routingPreference", &self.routing_preference)?;
        }
        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::SearchNearbyRequest {
    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.language_code.is_empty() {
            state.serialize_entry("languageCode", &self.language_code)?;
        }
        if !self.region_code.is_empty() {
            state.serialize_entry("regionCode", &self.region_code)?;
        }
        if !self.included_types.is_empty() {
            state.serialize_entry("includedTypes", &self.included_types)?;
        }
        if !self.excluded_types.is_empty() {
            state.serialize_entry("excludedTypes", &self.excluded_types)?;
        }
        if !self.included_primary_types.is_empty() {
            state.serialize_entry("includedPrimaryTypes", &self.included_primary_types)?;
        }
        if !self.excluded_primary_types.is_empty() {
            state.serialize_entry("excludedPrimaryTypes", &self.excluded_primary_types)?;
        }
        if !wkt::internal::is_default(&self.max_result_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("maxResultCount", &__With(&self.max_result_count))?;
        }
        if self.location_restriction.is_some() {
            state.serialize_entry("locationRestriction", &self.location_restriction)?;
        }
        if !wkt::internal::is_default(&self.rank_preference) {
            state.serialize_entry("rankPreference", &self.rank_preference)?;
        }
        if self.routing_parameters.is_some() {
            state.serialize_entry("routingParameters", &self.routing_parameters)?;
        }
        if !wkt::internal::is_default(&self.include_future_opening_businesses) {
            state.serialize_entry(
                "includeFutureOpeningBusinesses",
                &self.include_future_opening_businesses,
            )?;
        }
        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::search_nearby_request::LocationRestriction {
    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 let Some(value) = self.circle() {
            state.serialize_entry("circle", value)?;
        }
        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::SearchNearbyResponse {
    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.places.is_empty() {
            state.serialize_entry("places", &self.places)?;
        }
        if !self.routing_summaries.is_empty() {
            state.serialize_entry("routingSummaries", &self.routing_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::SearchTextRequest {
    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.text_query.is_empty() {
            state.serialize_entry("textQuery", &self.text_query)?;
        }
        if !self.language_code.is_empty() {
            state.serialize_entry("languageCode", &self.language_code)?;
        }
        if !self.region_code.is_empty() {
            state.serialize_entry("regionCode", &self.region_code)?;
        }
        if !wkt::internal::is_default(&self.rank_preference) {
            state.serialize_entry("rankPreference", &self.rank_preference)?;
        }
        if !self.included_type.is_empty() {
            state.serialize_entry("includedType", &self.included_type)?;
        }
        if !wkt::internal::is_default(&self.open_now) {
            state.serialize_entry("openNow", &self.open_now)?;
        }
        if !wkt::internal::is_default(&self.min_rating) {
            struct __With<'a>(&'a f64);
            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::F64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("minRating", &__With(&self.min_rating))?;
        }
        if !wkt::internal::is_default(&self.max_result_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("maxResultCount", &__With(&self.max_result_count))?;
        }
        if !self.price_levels.is_empty() {
            state.serialize_entry("priceLevels", &self.price_levels)?;
        }
        if !wkt::internal::is_default(&self.strict_type_filtering) {
            state.serialize_entry("strictTypeFiltering", &self.strict_type_filtering)?;
        }
        if self.location_bias.is_some() {
            state.serialize_entry("locationBias", &self.location_bias)?;
        }
        if self.location_restriction.is_some() {
            state.serialize_entry("locationRestriction", &self.location_restriction)?;
        }
        if self.ev_options.is_some() {
            state.serialize_entry("evOptions", &self.ev_options)?;
        }
        if self.routing_parameters.is_some() {
            state.serialize_entry("routingParameters", &self.routing_parameters)?;
        }
        if self.search_along_route_parameters.is_some() {
            state.serialize_entry(
                "searchAlongRouteParameters",
                &self.search_along_route_parameters,
            )?;
        }
        if !wkt::internal::is_default(&self.include_pure_service_area_businesses) {
            state.serialize_entry(
                "includePureServiceAreaBusinesses",
                &self.include_pure_service_area_businesses,
            )?;
        }
        if !wkt::internal::is_default(&self.include_future_opening_businesses) {
            state.serialize_entry(
                "includeFutureOpeningBusinesses",
                &self.include_future_opening_businesses,
            )?;
        }
        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::search_text_request::LocationBias {
    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 let Some(value) = self.rectangle() {
            state.serialize_entry("rectangle", value)?;
        }
        if let Some(value) = self.circle() {
            state.serialize_entry("circle", value)?;
        }
        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::search_text_request::LocationRestriction {
    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 let Some(value) = self.rectangle() {
            state.serialize_entry("rectangle", value)?;
        }
        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::search_text_request::EVOptions {
    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.minimum_charging_rate_kw) {
            struct __With<'a>(&'a f64);
            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::F64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "minimumChargingRateKw",
                &__With(&self.minimum_charging_rate_kw),
            )?;
        }
        if !self.connector_types.is_empty() {
            state.serialize_entry("connectorTypes", &self.connector_types)?;
        }
        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::search_text_request::SearchAlongRouteParameters {
    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.polyline.is_some() {
            state.serialize_entry("polyline", &self.polyline)?;
        }
        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::SearchTextResponse {
    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.places.is_empty() {
            state.serialize_entry("places", &self.places)?;
        }
        if !self.routing_summaries.is_empty() {
            state.serialize_entry("routingSummaries", &self.routing_summaries)?;
        }
        if !self.contextual_contents.is_empty() {
            state.serialize_entry("contextualContents", &self.contextual_contents)?;
        }
        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::GetPhotoMediaRequest {
    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 !wkt::internal::is_default(&self.max_width_px) {
            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("maxWidthPx", &__With(&self.max_width_px))?;
        }
        if !wkt::internal::is_default(&self.max_height_px) {
            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("maxHeightPx", &__With(&self.max_height_px))?;
        }
        if !wkt::internal::is_default(&self.skip_http_redirect) {
            state.serialize_entry("skipHttpRedirect", &self.skip_http_redirect)?;
        }
        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::PhotoMedia {
    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.photo_uri.is_empty() {
            state.serialize_entry("photoUri", &self.photo_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::GetPlaceRequest {
    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.language_code.is_empty() {
            state.serialize_entry("languageCode", &self.language_code)?;
        }
        if !self.region_code.is_empty() {
            state.serialize_entry("regionCode", &self.region_code)?;
        }
        if !self.session_token.is_empty() {
            state.serialize_entry("sessionToken", &self.session_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::AutocompletePlacesRequest {
    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.input.is_empty() {
            state.serialize_entry("input", &self.input)?;
        }
        if self.location_bias.is_some() {
            state.serialize_entry("locationBias", &self.location_bias)?;
        }
        if self.location_restriction.is_some() {
            state.serialize_entry("locationRestriction", &self.location_restriction)?;
        }
        if !self.included_primary_types.is_empty() {
            state.serialize_entry("includedPrimaryTypes", &self.included_primary_types)?;
        }
        if !self.included_region_codes.is_empty() {
            state.serialize_entry("includedRegionCodes", &self.included_region_codes)?;
        }
        if !self.language_code.is_empty() {
            state.serialize_entry("languageCode", &self.language_code)?;
        }
        if !self.region_code.is_empty() {
            state.serialize_entry("regionCode", &self.region_code)?;
        }
        if self.origin.is_some() {
            state.serialize_entry("origin", &self.origin)?;
        }
        if !wkt::internal::is_default(&self.input_offset) {
            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("inputOffset", &__With(&self.input_offset))?;
        }
        if !wkt::internal::is_default(&self.include_query_predictions) {
            state.serialize_entry("includeQueryPredictions", &self.include_query_predictions)?;
        }
        if !self.session_token.is_empty() {
            state.serialize_entry("sessionToken", &self.session_token)?;
        }
        if !wkt::internal::is_default(&self.include_pure_service_area_businesses) {
            state.serialize_entry(
                "includePureServiceAreaBusinesses",
                &self.include_pure_service_area_businesses,
            )?;
        }
        if !wkt::internal::is_default(&self.include_future_opening_businesses) {
            state.serialize_entry(
                "includeFutureOpeningBusinesses",
                &self.include_future_opening_businesses,
            )?;
        }
        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::autocomplete_places_request::LocationBias {
    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 let Some(value) = self.rectangle() {
            state.serialize_entry("rectangle", value)?;
        }
        if let Some(value) = self.circle() {
            state.serialize_entry("circle", value)?;
        }
        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::autocomplete_places_request::LocationRestriction {
    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 let Some(value) = self.rectangle() {
            state.serialize_entry("rectangle", value)?;
        }
        if let Some(value) = self.circle() {
            state.serialize_entry("circle", value)?;
        }
        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::AutocompletePlacesResponse {
    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.suggestions.is_empty() {
            state.serialize_entry("suggestions", &self.suggestions)?;
        }
        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::autocomplete_places_response::Suggestion {
    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 let Some(value) = self.place_prediction() {
            state.serialize_entry("placePrediction", value)?;
        }
        if let Some(value) = self.query_prediction() {
            state.serialize_entry("queryPrediction", value)?;
        }
        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::autocomplete_places_response::suggestion::StringRange {
    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.start_offset) {
            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("startOffset", &__With(&self.start_offset))?;
        }
        if !wkt::internal::is_default(&self.end_offset) {
            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("endOffset", &__With(&self.end_offset))?;
        }
        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::autocomplete_places_response::suggestion::FormattableText {
    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.text.is_empty() {
            state.serialize_entry("text", &self.text)?;
        }
        if !self.matches.is_empty() {
            state.serialize_entry("matches", &self.matches)?;
        }
        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::autocomplete_places_response::suggestion::StructuredFormat {
    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.main_text.is_some() {
            state.serialize_entry("mainText", &self.main_text)?;
        }
        if self.secondary_text.is_some() {
            state.serialize_entry("secondaryText", &self.secondary_text)?;
        }
        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::autocomplete_places_response::suggestion::PlacePrediction {
    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.place.is_empty() {
            state.serialize_entry("place", &self.place)?;
        }
        if !self.place_id.is_empty() {
            state.serialize_entry("placeId", &self.place_id)?;
        }
        if self.text.is_some() {
            state.serialize_entry("text", &self.text)?;
        }
        if self.structured_format.is_some() {
            state.serialize_entry("structuredFormat", &self.structured_format)?;
        }
        if !self.types.is_empty() {
            state.serialize_entry("types", &self.types)?;
        }
        if !wkt::internal::is_default(&self.distance_meters) {
            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("distanceMeters", &__With(&self.distance_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::autocomplete_places_response::suggestion::QueryPrediction {
    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.text.is_some() {
            state.serialize_entry("text", &self.text)?;
        }
        if self.structured_format.is_some() {
            state.serialize_entry("structuredFormat", &self.structured_format)?;
        }
        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::Polyline {
    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 let Some(value) = self.encoded_polyline() {
            state.serialize_entry("encodedPolyline", value)?;
        }
        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::PriceRange {
    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.start_price.is_some() {
            state.serialize_entry("startPrice", &self.start_price)?;
        }
        if self.end_price.is_some() {
            state.serialize_entry("endPrice", &self.end_price)?;
        }
        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::References {
    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.reviews.is_empty() {
            state.serialize_entry("reviews", &self.reviews)?;
        }
        if !self.places.is_empty() {
            state.serialize_entry("places", &self.places)?;
        }
        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::Review {
    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.relative_publish_time_description.is_empty() {
            state.serialize_entry(
                "relativePublishTimeDescription",
                &self.relative_publish_time_description,
            )?;
        }
        if self.text.is_some() {
            state.serialize_entry("text", &self.text)?;
        }
        if self.original_text.is_some() {
            state.serialize_entry("originalText", &self.original_text)?;
        }
        if !wkt::internal::is_default(&self.rating) {
            struct __With<'a>(&'a f64);
            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::F64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("rating", &__With(&self.rating))?;
        }
        if self.author_attribution.is_some() {
            state.serialize_entry("authorAttribution", &self.author_attribution)?;
        }
        if self.publish_time.is_some() {
            state.serialize_entry("publishTime", &self.publish_time)?;
        }
        if !self.flag_content_uri.is_empty() {
            state.serialize_entry("flagContentUri", &self.flag_content_uri)?;
        }
        if !self.google_maps_uri.is_empty() {
            state.serialize_entry("googleMapsUri", &self.google_maps_uri)?;
        }
        if self.visit_date.is_some() {
            state.serialize_entry("visitDate", &self.visit_date)?;
        }
        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::RouteModifiers {
    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.avoid_tolls) {
            state.serialize_entry("avoidTolls", &self.avoid_tolls)?;
        }
        if !wkt::internal::is_default(&self.avoid_highways) {
            state.serialize_entry("avoidHighways", &self.avoid_highways)?;
        }
        if !wkt::internal::is_default(&self.avoid_ferries) {
            state.serialize_entry("avoidFerries", &self.avoid_ferries)?;
        }
        if !wkt::internal::is_default(&self.avoid_indoor) {
            state.serialize_entry("avoidIndoor", &self.avoid_indoor)?;
        }
        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::RoutingSummary {
    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.legs.is_empty() {
            state.serialize_entry("legs", &self.legs)?;
        }
        if !self.directions_uri.is_empty() {
            state.serialize_entry("directionsUri", &self.directions_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::routing_summary::Leg {
    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.duration.is_some() {
            state.serialize_entry("duration", &self.duration)?;
        }
        if !wkt::internal::is_default(&self.distance_meters) {
            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("distanceMeters", &__With(&self.distance_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::TransitStation {
    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.display_name.is_some() {
            state.serialize_entry("displayName", &self.display_name)?;
        }
        if !self.agencies.is_empty() {
            state.serialize_entry("agencies", &self.agencies)?;
        }
        if !self.stops.is_empty() {
            state.serialize_entry("stops", &self.stops)?;
        }
        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::TransitAgency {
    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.display_name.is_some() {
            state.serialize_entry("displayName", &self.display_name)?;
        }
        if !self.url.is_empty() {
            state.serialize_entry("url", &self.url)?;
        }
        if !self.fare_url.is_empty() {
            state.serialize_entry("fareUrl", &self.fare_url)?;
        }
        if self.icon.is_some() {
            state.serialize_entry("icon", &self.icon)?;
        }
        if !self.lines.is_empty() {
            state.serialize_entry("lines", &self.lines)?;
        }
        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::TransitLine {
    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 !wkt::internal::is_default(&self.vehicle_type) {
            state.serialize_entry("vehicleType", &self.vehicle_type)?;
        }
        if self.display_name.is_some() {
            state.serialize_entry("displayName", &self.display_name)?;
        }
        if self.short_display_name.is_some() {
            state.serialize_entry("shortDisplayName", &self.short_display_name)?;
        }
        if !self.text_color.is_empty() {
            state.serialize_entry("textColor", &self.text_color)?;
        }
        if !self.background_color.is_empty() {
            state.serialize_entry("backgroundColor", &self.background_color)?;
        }
        if !self.url.is_empty() {
            state.serialize_entry("url", &self.url)?;
        }
        if self.icon.is_some() {
            state.serialize_entry("icon", &self.icon)?;
        }
        if self.vehicle_icon.is_some() {
            state.serialize_entry("vehicleIcon", &self.vehicle_icon)?;
        }
        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::TransitStop {
    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.display_name.is_some() {
            state.serialize_entry("displayName", &self.display_name)?;
        }
        if self.platform_code.is_some() {
            state.serialize_entry("platformCode", &self.platform_code)?;
        }
        if self.signage_text.is_some() {
            state.serialize_entry("signageText", &self.signage_text)?;
        }
        if self.stop_code.is_some() {
            state.serialize_entry("stopCode", &self.stop_code)?;
        }
        if self.location.is_some() {
            state.serialize_entry("location", &self.location)?;
        }
        if self.wheelchair_accessible_entrance.is_some() {
            state.serialize_entry(
                "wheelchairAccessibleEntrance",
                &self.wheelchair_accessible_entrance,
            )?;
        }
        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::TransitIcon {
    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.url.is_empty() {
            state.serialize_entry("url", &self.url)?;
        }
        if !wkt::internal::is_default(&self.name_included) {
            state.serialize_entry("nameIncluded", &self.name_included)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}