google_maps_geocode_v4/

model.rs

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

#![allow(rustdoc::bare_urls)]
#![allow(rustdoc::broken_intra_doc_links)]
#![allow(rustdoc::invalid_html_tags)]
#![allow(rustdoc::redundant_explicit_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gaxi;
extern crate google_cloud_gax;
extern crate google_cloud_type;
extern crate google_geo_type;
extern crate serde;
extern crate serde_json;
extern crate serde_with;
extern crate std;
extern crate tracing;
extern crate wkt;

mod debug;
mod deserialize;
mod serialize;

/// Request message for DestinationService.SearchDestinations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SearchDestinationsRequest {
    /// Optional. The travel modes to filter navigation points for. This influences
    /// the `navigation_points` field returned in the response. If empty,
    /// navigation points of all travel modes are returned.
    pub travel_modes: std::vec::Vec<crate::model::navigation_point::TravelMode>,

    /// Optional. Language in which the results should be returned.
    pub language_code: std::string::String,

    /// Optional. Region code. The region code, specified as a ccTLD ("top-level
    /// domain") two-character value. The parameter affects results based on
    /// applicable law. This parameter also influences, but not fully restricts,
    /// results from the service.
    pub region_code: std::string::String,

    /// Query for the primary destination. This can be either a place, a fully
    /// specified address, or a LatLng location. Some places and addresses with
    /// minimal information won't be able to be turned into a destination.
    ///
    /// The destinations are built around the specified primary query.
    ///
    /// Note: only places and addresses that can have a navigational destination
    /// are supported. For example, a place that represents a house or an apartment
    /// complex can be used as the primary query, but places that represent a
    /// locality or an administrative area cannot be used as the primary query.
    pub primary_query: std::option::Option<crate::model::search_destinations_request::PrimaryQuery>,

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

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

    /// Sets the value of [travel_modes][crate::model::SearchDestinationsRequest::travel_modes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::SearchDestinationsRequest;
    /// use google_maps_geocode_v4::model::navigation_point::TravelMode;
    /// let x = SearchDestinationsRequest::new().set_travel_modes([
    ///     TravelMode::Drive,
    ///     TravelMode::Walk,
    /// ]);
    /// ```
    pub fn set_travel_modes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::navigation_point::TravelMode>,
    {
        use std::iter::Iterator;
        self.travel_modes = v.into_iter().map(|i| i.into()).collect();
        self
    }

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

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

    /// Sets the value of [primary_query][crate::model::SearchDestinationsRequest::primary_query].
    ///
    /// Note that all the setters affecting `primary_query` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::SearchDestinationsRequest;
    /// use google_maps_geocode_v4::model::search_destinations_request::PrimaryQuery;
    /// let x = SearchDestinationsRequest::new().set_primary_query(Some(PrimaryQuery::Place("example".to_string())));
    /// ```
    pub fn set_primary_query<
        T: std::convert::Into<
                std::option::Option<crate::model::search_destinations_request::PrimaryQuery>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.primary_query = v.into();
        self
    }

    /// The value of [primary_query][crate::model::SearchDestinationsRequest::primary_query]
    /// if it holds a `Place`, `None` if the field is not set or
    /// holds a different branch.
    pub fn place(&self) -> std::option::Option<&std::string::String> {
        #[allow(unreachable_patterns)]
        self.primary_query.as_ref().and_then(|v| match v {
            crate::model::search_destinations_request::PrimaryQuery::Place(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [primary_query][crate::model::SearchDestinationsRequest::primary_query]
    /// to hold a `Place`.
    ///
    /// Note that all the setters affecting `primary_query` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::SearchDestinationsRequest;
    /// let x = SearchDestinationsRequest::new().set_place("example");
    /// assert!(x.place().is_some());
    /// assert!(x.address_query().is_none());
    /// assert!(x.location_query().is_none());
    /// ```
    pub fn set_place<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.primary_query = std::option::Option::Some(
            crate::model::search_destinations_request::PrimaryQuery::Place(v.into()),
        );
        self
    }

    /// The value of [primary_query][crate::model::SearchDestinationsRequest::primary_query]
    /// if it holds a `AddressQuery`, `None` if the field is not set or
    /// holds a different branch.
    pub fn address_query(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::model::search_destinations_request::AddressQuery>,
    > {
        #[allow(unreachable_patterns)]
        self.primary_query.as_ref().and_then(|v| match v {
            crate::model::search_destinations_request::PrimaryQuery::AddressQuery(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [primary_query][crate::model::SearchDestinationsRequest::primary_query]
    /// to hold a `AddressQuery`.
    ///
    /// Note that all the setters affecting `primary_query` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::SearchDestinationsRequest;
    /// use google_maps_geocode_v4::model::search_destinations_request::AddressQuery;
    /// let x = SearchDestinationsRequest::new().set_address_query(AddressQuery::default()/* use setters */);
    /// assert!(x.address_query().is_some());
    /// assert!(x.place().is_none());
    /// assert!(x.location_query().is_none());
    /// ```
    pub fn set_address_query<
        T: std::convert::Into<
                std::boxed::Box<crate::model::search_destinations_request::AddressQuery>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.primary_query = std::option::Option::Some(
            crate::model::search_destinations_request::PrimaryQuery::AddressQuery(v.into()),
        );
        self
    }

    /// The value of [primary_query][crate::model::SearchDestinationsRequest::primary_query]
    /// if it holds a `LocationQuery`, `None` if the field is not set or
    /// holds a different branch.
    pub fn location_query(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::model::search_destinations_request::LocationQuery>,
    > {
        #[allow(unreachable_patterns)]
        self.primary_query.as_ref().and_then(|v| match v {
            crate::model::search_destinations_request::PrimaryQuery::LocationQuery(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [primary_query][crate::model::SearchDestinationsRequest::primary_query]
    /// to hold a `LocationQuery`.
    ///
    /// Note that all the setters affecting `primary_query` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::SearchDestinationsRequest;
    /// use google_maps_geocode_v4::model::search_destinations_request::LocationQuery;
    /// let x = SearchDestinationsRequest::new().set_location_query(LocationQuery::default()/* use setters */);
    /// assert!(x.location_query().is_some());
    /// assert!(x.place().is_none());
    /// assert!(x.address_query().is_none());
    /// ```
    pub fn set_location_query<
        T: std::convert::Into<
                std::boxed::Box<crate::model::search_destinations_request::LocationQuery>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.primary_query = std::option::Option::Some(
            crate::model::search_destinations_request::PrimaryQuery::LocationQuery(v.into()),
        );
        self
    }
}

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

/// Defines additional types related to [SearchDestinationsRequest].
pub mod search_destinations_request {
    #[allow(unused_imports)]
    use super::*;

    /// The street address that you want to search for. Specify addresses in
    /// accordance with the format used by the national postal service of the
    /// country concerned.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct AddressQuery {
        /// The address query.
        pub kind:
            std::option::Option<crate::model::search_destinations_request::address_query::Kind>,

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

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

        /// Sets the value of [kind][crate::model::search_destinations_request::AddressQuery::kind].
        ///
        /// Note that all the setters affecting `kind` are mutually
        /// exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_geocode_v4::model::search_destinations_request::AddressQuery;
        /// use google_maps_geocode_v4::model::search_destinations_request::address_query::Kind;
        /// let x = AddressQuery::new().set_kind(Some(Kind::AddressQuery("example".to_string())));
        /// ```
        pub fn set_kind<
            T: std::convert::Into<
                    std::option::Option<
                        crate::model::search_destinations_request::address_query::Kind,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.kind = v.into();
            self
        }

        /// The value of [kind][crate::model::search_destinations_request::AddressQuery::kind]
        /// if it holds a `Address`, `None` if the field is not set or
        /// holds a different branch.
        pub fn address(
            &self,
        ) -> std::option::Option<&std::boxed::Box<google_cloud_type::model::PostalAddress>>
        {
            #[allow(unreachable_patterns)]
            self.kind.as_ref().and_then(|v| match v {
                crate::model::search_destinations_request::address_query::Kind::Address(v) => {
                    std::option::Option::Some(v)
                }
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [kind][crate::model::search_destinations_request::AddressQuery::kind]
        /// to hold a `Address`.
        ///
        /// Note that all the setters affecting `kind` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_geocode_v4::model::search_destinations_request::AddressQuery;
        /// use google_cloud_type::model::PostalAddress;
        /// let x = AddressQuery::new().set_address(PostalAddress::default()/* use setters */);
        /// assert!(x.address().is_some());
        /// assert!(x.address_query().is_none());
        /// ```
        pub fn set_address<
            T: std::convert::Into<std::boxed::Box<google_cloud_type::model::PostalAddress>>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.kind = std::option::Option::Some(
                crate::model::search_destinations_request::address_query::Kind::Address(v.into()),
            );
            self
        }

        /// The value of [kind][crate::model::search_destinations_request::AddressQuery::kind]
        /// if it holds a `AddressQuery`, `None` if the field is not set or
        /// holds a different branch.
        pub fn address_query(&self) -> std::option::Option<&std::string::String> {
            #[allow(unreachable_patterns)]
            self.kind.as_ref().and_then(|v| match v {
                crate::model::search_destinations_request::address_query::Kind::AddressQuery(v) => {
                    std::option::Option::Some(v)
                }
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [kind][crate::model::search_destinations_request::AddressQuery::kind]
        /// to hold a `AddressQuery`.
        ///
        /// Note that all the setters affecting `kind` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_geocode_v4::model::search_destinations_request::AddressQuery;
        /// let x = AddressQuery::new().set_address_query("example");
        /// assert!(x.address_query().is_some());
        /// assert!(x.address().is_none());
        /// ```
        pub fn set_address_query<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.kind = std::option::Option::Some(
                crate::model::search_destinations_request::address_query::Kind::AddressQuery(
                    v.into(),
                ),
            );
            self
        }
    }

    impl wkt::message::Message for AddressQuery {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.geocode.v4.SearchDestinationsRequest.AddressQuery"
        }
    }

    /// Defines additional types related to [AddressQuery].
    pub mod address_query {
        #[allow(unused_imports)]
        use super::*;

        /// The address query.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Kind {
            /// A street address in postal address format.
            Address(std::boxed::Box<google_cloud_type::model::PostalAddress>),
            /// A street address formatted as a single line.
            AddressQuery(std::string::String),
        }
    }

    /// A location query to identify a nearby primary destination.
    ///
    /// Note: if the location query is within a building that contains subpremises,
    /// it is possible that the returned primary place is a subpremise. In these
    /// cases, the `containing_places` field will include the building.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct LocationQuery {
        /// Optional. Filters to apply to destination candidates.
        pub place_filter: std::option::Option<
            crate::model::search_destinations_request::location_query::PlaceFilter,
        >,

        /// The location query.
        pub kind:
            std::option::Option<crate::model::search_destinations_request::location_query::Kind>,

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

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

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

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

        /// Sets the value of [kind][crate::model::search_destinations_request::LocationQuery::kind].
        ///
        /// Note that all the setters affecting `kind` are mutually
        /// exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_geocode_v4::model::search_destinations_request::LocationQuery;
        /// use google_cloud_type::model::LatLng;
        /// let x = LocationQuery::new().set_kind(Some(
        ///     google_maps_geocode_v4::model::search_destinations_request::location_query::Kind::Location(LatLng::default().into())));
        /// ```
        pub fn set_kind<
            T: std::convert::Into<
                    std::option::Option<
                        crate::model::search_destinations_request::location_query::Kind,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.kind = v.into();
            self
        }

        /// The value of [kind][crate::model::search_destinations_request::LocationQuery::kind]
        /// if it holds a `Location`, `None` if the field is not set or
        /// holds a different branch.
        pub fn location(
            &self,
        ) -> std::option::Option<&std::boxed::Box<google_cloud_type::model::LatLng>> {
            #[allow(unreachable_patterns)]
            self.kind.as_ref().and_then(|v| match v {
                crate::model::search_destinations_request::location_query::Kind::Location(v) => {
                    std::option::Option::Some(v)
                }
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [kind][crate::model::search_destinations_request::LocationQuery::kind]
        /// to hold a `Location`.
        ///
        /// Note that all the setters affecting `kind` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_geocode_v4::model::search_destinations_request::LocationQuery;
        /// use google_cloud_type::model::LatLng;
        /// let x = LocationQuery::new().set_location(LatLng::default()/* use setters */);
        /// assert!(x.location().is_some());
        /// ```
        pub fn set_location<
            T: std::convert::Into<std::boxed::Box<google_cloud_type::model::LatLng>>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.kind = std::option::Option::Some(
                crate::model::search_destinations_request::location_query::Kind::Location(v.into()),
            );
            self
        }
    }

    impl wkt::message::Message for LocationQuery {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.geocode.v4.SearchDestinationsRequest.LocationQuery"
        }
    }

    /// Defines additional types related to [LocationQuery].
    pub mod location_query {
        #[allow(unused_imports)]
        use super::*;

        /// Filters to apply to destination candidates.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct PlaceFilter {

            /// Optional. If specified, all destinations are guaranteed to have a
            /// primary place with this structure type. This can result in filtering
            /// out some destinations, or in coarsening/refining the returned
            /// destinations.
            ///
            /// For example, if `GROUNDS` is specified, all returned destinations will
            /// have a primary place with the `GROUNDS` structure type. This can
            /// result in filtering out some destinations that are not part of a
            /// grounds, or in coarsening the returned destinations to the grounds
            /// level.
            ///
            /// Another use of this field is to more easily extract building display
            /// polygons. For example, if `BUILDING` is specified, the primary place's
            /// display polygon will be for the building at the specified location.
            pub structure_type: crate::model::place_view::StructureType,

            /// Optional. If specified, only returns destinations that meet the
            /// corresponding addressability criteria.
            pub addressability: crate::model::search_destinations_request::location_query::place_filter::Addressability,

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

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

            /// Sets the value of [structure_type][crate::model::search_destinations_request::location_query::PlaceFilter::structure_type].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_maps_geocode_v4::model::search_destinations_request::location_query::PlaceFilter;
            /// use google_maps_geocode_v4::model::place_view::StructureType;
            /// let x0 = PlaceFilter::new().set_structure_type(StructureType::Point);
            /// let x1 = PlaceFilter::new().set_structure_type(StructureType::Section);
            /// let x2 = PlaceFilter::new().set_structure_type(StructureType::Building);
            /// ```
            pub fn set_structure_type<
                T: std::convert::Into<crate::model::place_view::StructureType>,
            >(
                mut self,
                v: T,
            ) -> Self {
                self.structure_type = v.into();
                self
            }

            /// Sets the value of [addressability][crate::model::search_destinations_request::location_query::PlaceFilter::addressability].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_maps_geocode_v4::model::search_destinations_request::location_query::PlaceFilter;
            /// use google_maps_geocode_v4::model::search_destinations_request::location_query::place_filter::Addressability;
            /// let x0 = PlaceFilter::new().set_addressability(Addressability::Any);
            /// let x1 = PlaceFilter::new().set_addressability(Addressability::Primary);
            /// let x2 = PlaceFilter::new().set_addressability(Addressability::Weak);
            /// ```
            pub fn set_addressability<T: std::convert::Into<crate::model::search_destinations_request::location_query::place_filter::Addressability>>(mut self, v: T) -> Self{
                self.addressability = v.into();
                self
            }
        }

        impl wkt::message::Message for PlaceFilter {
            fn typename() -> &'static str {
                "type.googleapis.com/google.maps.geocode.v4.SearchDestinationsRequest.LocationQuery.PlaceFilter"
            }
        }

        /// Defines additional types related to [PlaceFilter].
        pub mod place_filter {
            #[allow(unused_imports)]
            use super::*;

            /// Defines options for addressability filtering. New values may be added
            /// in the future.
            ///
            /// # Working with unknown values
            ///
            /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
            /// additional enum variants at any time. Adding new variants is not considered
            /// a breaking change. Applications should write their code in anticipation of:
            ///
            /// - New values appearing in future releases of the client library, **and**
            /// - New values received dynamically, without application changes.
            ///
            /// Please consult the [Working with enums] section in the user guide for some
            /// guidelines.
            ///
            /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
            #[derive(Clone, Debug, PartialEq)]
            #[non_exhaustive]
            pub enum Addressability {
                /// When unspecified, the service will choose a sensible default.
                Unspecified,
                /// Addressability is not a filtering criteria. Destinations are returned
                /// regardless of their addressability.
                Any,
                /// All destinations returned will have a primary place with a street
                /// level address or name.
                Primary,
                /// All destinations returned will have either a primary place or a
                /// subdestination with a street level address or name.
                Weak,
                /// If set, the enum was initialized with an unknown value.
                ///
                /// Applications can examine the value using [Addressability::value] or
                /// [Addressability::name].
                UnknownValue(addressability::UnknownValue),
            }

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

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

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

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

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

            impl std::convert::From<i32> for Addressability {
                fn from(value: i32) -> Self {
                    match value {
                        0 => Self::Unspecified,
                        1 => Self::Any,
                        2 => Self::Primary,
                        3 => Self::Weak,
                        _ => Self::UnknownValue(addressability::UnknownValue(
                            wkt::internal::UnknownEnumValue::Integer(value),
                        )),
                    }
                }
            }

            impl std::convert::From<&str> for Addressability {
                fn from(value: &str) -> Self {
                    use std::string::ToString;
                    match value {
                        "ADDRESSABILITY_UNSPECIFIED" => Self::Unspecified,
                        "ANY" => Self::Any,
                        "PRIMARY" => Self::Primary,
                        "WEAK" => Self::Weak,
                        _ => Self::UnknownValue(addressability::UnknownValue(
                            wkt::internal::UnknownEnumValue::String(value.to_string()),
                        )),
                    }
                }
            }

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

            impl<'de> serde::de::Deserialize<'de> for Addressability {
                fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    deserializer.deserialize_any(wkt::internal::EnumVisitor::<Addressability>::new(
                        ".google.maps.geocode.v4.SearchDestinationsRequest.LocationQuery.PlaceFilter.Addressability"))
                }
            }
        }

        /// The location query.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Kind {
            /// A precise LatLng location.
            Location(std::boxed::Box<google_cloud_type::model::LatLng>),
        }
    }

    /// Query for the primary destination. This can be either a place, a fully
    /// specified address, or a LatLng location. Some places and addresses with
    /// minimal information won't be able to be turned into a destination.
    ///
    /// The destinations are built around the specified primary query.
    ///
    /// Note: only places and addresses that can have a navigational destination
    /// are supported. For example, a place that represents a house or an apartment
    /// complex can be used as the primary query, but places that represent a
    /// locality or an administrative area cannot be used as the primary query.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum PrimaryQuery {
        /// The resource name of a place, in `places/{place_id}` format.
        Place(std::string::String),
        /// A street address.
        AddressQuery(std::boxed::Box<crate::model::search_destinations_request::AddressQuery>),
        /// A precise location.
        LocationQuery(std::boxed::Box<crate::model::search_destinations_request::LocationQuery>),
    }
}

/// Response message for DestinationService.SearchDestinations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SearchDestinationsResponse {
    /// A list of destinations.
    ///
    /// The service returns one result if a primary destination can be
    /// unambiguously identified from the primary query. Otherwise, the service
    /// might return multiple results for disambiguation or zero results.
    pub destinations: std::vec::Vec<crate::model::Destination>,

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

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

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

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

/// A destination. This includes the primary place, related places,
/// entrances, and navigation points.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Destination {
    /// The primary place identified by the `primary_query` in the request.
    pub primary: std::option::Option<crate::model::PlaceView>,

    /// The less precise places that the primary place is contained by.
    /// For example, the apartment complex that contains this building.
    pub containing_places: std::vec::Vec<crate::model::PlaceView>,

    /// More precise sub-destinations of the primary place. For example, units
    /// contained in a building.
    ///
    /// Note: compared to the
    /// [SubDestination](/maps/documentation/places/web-service/reference/rest/v1/places#SubDestination)
    /// returned by the Places API, this list of sub-destinations is more
    /// exhaustive, and each sub-destination contains more information.
    pub sub_destinations: std::vec::Vec<crate::model::PlaceView>,

    /// Landmarks that can be used to communicate where the destination is
    /// or help with arrival.
    pub landmarks: std::vec::Vec<crate::model::Landmark>,

    /// Entrances for this destination.
    pub entrances: std::vec::Vec<crate::model::Entrance>,

    /// Navigation points for this destination.
    pub navigation_points: std::vec::Vec<crate::model::NavigationPoint>,

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

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

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

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

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

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

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

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

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

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

/// Represents a view of a
/// [Place](https://developers.google.com/maps/documentation/places/web-service/reference/rest/v1/places#resource:-place)
/// in the Places API. It also provides additional information specific to
/// destinations, such as the structure type and the display polygon.
///
/// In some cases, a `PlaceView` with the same place ID might differ from what
/// is being returned by the Places API for the `types` and
/// `display_name` fields.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PlaceView {
    /// This Place's resource name, in `places/{placeId}` format.  Can be used to
    /// look up the Place.
    pub place: std::string::String,

    /// The unique identifier of a place.
    pub place_id: std::string::String,

    /// Human readable place description. For example, "Gate B", "McDonalds"
    pub display_name: std::option::Option<google_cloud_type::model::LocalizedText>,

    /// The primary place type of this place. See
    /// <https://developers.google.com/maps/documentation/places/web-service/place-types>
    /// for the list of possible values.
    ///
    /// Note: This field is not always populated. Be prepared to use the `types`
    /// field in such situations.
    pub primary_type: std::string::String,

    /// All associated place types of this place. See
    /// <https://developers.google.com/maps/documentation/places/web-service/place-types>
    /// for the list of possible values.
    pub types: std::vec::Vec<std::string::String>,

    /// One line address.
    pub formatted_address: std::string::String,

    /// Structured address.
    pub postal_address: std::option::Option<google_cloud_type::model::PostalAddress>,

    /// The type of structure corresponding to this place.
    pub structure_type: crate::model::place_view::StructureType,

    /// The location of this place. For places with display polygons, this can
    /// represent a good spot to put a marker on the map.
    pub location: std::option::Option<google_cloud_type::model::LatLng>,

    /// The polygon outline of the place in GeoJSON format, using the RFC 7946
    /// format: <https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.6>.
    ///
    /// Note: The RFC 7946 format supports MultiPolygons, so one `display_polygon`
    /// object can represent multiple polygons.
    pub display_polygon: std::option::Option<wkt::Struct>,

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

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

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

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

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

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

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

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

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

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

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

    /// Sets the value of [structure_type][crate::model::PlaceView::structure_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::PlaceView;
    /// use google_maps_geocode_v4::model::place_view::StructureType;
    /// let x0 = PlaceView::new().set_structure_type(StructureType::Point);
    /// let x1 = PlaceView::new().set_structure_type(StructureType::Section);
    /// let x2 = PlaceView::new().set_structure_type(StructureType::Building);
    /// ```
    pub fn set_structure_type<T: std::convert::Into<crate::model::place_view::StructureType>>(
        mut self,
        v: T,
    ) -> Self {
        self.structure_type = v.into();
        self
    }

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

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

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

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

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

/// Defines additional types related to [PlaceView].
pub mod place_view {
    #[allow(unused_imports)]
    use super::*;

    /// The type of structure that this place represents.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum StructureType {
        /// Not used.
        Unspecified,
        /// A point location.
        Point,
        /// A sub-section of a building.
        Section,
        /// A building.
        Building,
        /// A large area that typically contains multiple buildings, such as a
        /// university campus, an apartment complex, or a shopping mall.
        Grounds,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [StructureType::value] or
        /// [StructureType::name].
        UnknownValue(structure_type::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for StructureType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Point,
                2 => Self::Section,
                3 => Self::Building,
                4 => Self::Grounds,
                _ => Self::UnknownValue(structure_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for StructureType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "STRUCTURE_TYPE_UNSPECIFIED" => Self::Unspecified,
                "POINT" => Self::Point,
                "SECTION" => Self::Section,
                "BUILDING" => Self::Building,
                "GROUNDS" => Self::Grounds,
                _ => Self::UnknownValue(structure_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// An entrance is a single latitude/longitude coordinate pair that defines the
/// location of an entry and exit point for a place.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Entrance {
    /// The location of the entrance.
    pub location: std::option::Option<google_cloud_type::model::LatLng>,

    /// A list of tags that describe the entrance.
    pub tags: std::vec::Vec<crate::model::entrance::Tag>,

    /// The structure this entrance is physically located on, in
    /// `places/{place_id}` format.
    pub place: std::string::String,

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

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

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

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

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

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

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

/// Defines additional types related to [Entrance].
pub mod entrance {
    #[allow(unused_imports)]
    use super::*;

    /// Characteristics that describe an entrance.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Tag {
        /// Not used.
        Unspecified,
        /// The entrance likely provides physical access to the primary place in
        /// the returned destination. A place can have multiple preferred entrances.
        /// If an entrance does not have this tag, it means the entrance is
        /// physically on the same building as the primary place, but does not
        /// necessarily provide access to the place.
        ///
        /// For example, if the primary place is a restaurant in a strip mall, the
        /// "PREFERRED" entrances will be the ones that likely lead into the
        /// restaurant itself, while the other returned entrances will be other
        /// entrances for the building, such as entrances into other restaurants in
        /// the strip mall.
        ///
        /// If the primary place is a building itself, the `PREFERRED` entrances
        /// will be the ones that lead into the "main" part of the building. For
        /// example, in a shopping center the `PREFERRED` entrances will be the ones
        /// that allow access to the main foyer area, but if an entrance only
        /// provides access to a store on the side of the building, it won't be a
        /// `PREFERRED` entrance.
        ///
        /// Note: a `PREFERRED` entrance might not provide access to the primary
        /// place, and a non-`PREFERRED` entrance might provide access to the
        /// primary place.
        Preferred,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Tag::value] or
        /// [Tag::name].
        UnknownValue(tag::UnknownValue),
    }

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

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

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

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

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

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

    impl std::convert::From<&str> for Tag {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TAG_UNSPECIFIED" => Self::Unspecified,
                "PREFERRED" => Self::Preferred,
                _ => Self::UnknownValue(tag::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// A navigation point is a location next to a road where navigation can end.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NavigationPoint {
    /// Output only. A token that can be used to identify this navigation point.
    pub navigation_point_token: std::string::String,

    /// The display name of this navigation point. For example, "5th Ave" or "Gate
    /// B".
    pub display_name: std::option::Option<google_cloud_type::model::LocalizedText>,

    /// A point next to the road segment where navigation should end. The point is
    /// intentionally slightly offset from the road's centerline to clearly mark
    /// the side of the road where the place is located.
    pub location: std::option::Option<google_cloud_type::model::LatLng>,

    /// Travel modes that are appropriate for this navigation point.
    pub travel_modes: std::vec::Vec<crate::model::navigation_point::TravelMode>,

    /// Lists `usages` supported by this navigation point. If empty, it does not
    /// necessarily mean its usage is restricted in any way. All navigation
    /// points can be used for general navigation.
    pub usages: std::vec::Vec<crate::model::navigation_point::Usage>,

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

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

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

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

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

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

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

    /// Sets the value of [travel_modes][crate::model::NavigationPoint::travel_modes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::NavigationPoint;
    /// use google_maps_geocode_v4::model::navigation_point::TravelMode;
    /// let x = NavigationPoint::new().set_travel_modes([
    ///     TravelMode::Drive,
    ///     TravelMode::Walk,
    /// ]);
    /// ```
    pub fn set_travel_modes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::navigation_point::TravelMode>,
    {
        use std::iter::Iterator;
        self.travel_modes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [usages][crate::model::NavigationPoint::usages].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::NavigationPoint;
    /// use google_maps_geocode_v4::model::navigation_point::Usage;
    /// let x = NavigationPoint::new().set_usages([
    ///     Usage::Unknown,
    ///     Usage::Dropoff,
    ///     Usage::Pickup,
    /// ]);
    /// ```
    pub fn set_usages<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::navigation_point::Usage>,
    {
        use std::iter::Iterator;
        self.usages = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

/// Defines additional types related to [NavigationPoint].
pub mod navigation_point {
    #[allow(unused_imports)]
    use super::*;

    /// Travel modes that are appropriate for this navigation point.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum TravelMode {
        /// Not used.
        Unspecified,
        /// Suitable for driving.
        Drive,
        /// Suitable for walking.
        Walk,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [TravelMode::value] or
        /// [TravelMode::name].
        UnknownValue(travel_mode::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for TravelMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Drive,
                2 => Self::Walk,
                _ => Self::UnknownValue(travel_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for TravelMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TRAVEL_MODE_UNSPECIFIED" => Self::Unspecified,
                "DRIVE" => Self::Drive,
                "WALK" => Self::Walk,
                _ => Self::UnknownValue(travel_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

    /// Usages supported by this navigation point.
    /// New values may be added in the future.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Usage {
        /// Not used.
        Unspecified,
        /// Indicates that the usage type is unknown.
        Unknown,
        /// Suitable for dropping off a passenger. For example, a rideshare drop off
        /// location.
        Dropoff,
        /// Suitable for picking up a passenger. For example, a rideshare pick up
        /// location.
        Pickup,
        /// Suitable for parking. For example, within a parking lot.
        Parking,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Usage::value] or
        /// [Usage::name].
        UnknownValue(usage::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for Usage {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Unknown,
                2 => Self::Dropoff,
                3 => Self::Pickup,
                4 => Self::Parking,
                _ => Self::UnknownValue(usage::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Usage {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "USAGE_UNSPECIFIED" => Self::Unspecified,
                "UNKNOWN" => Self::Unknown,
                "DROPOFF" => Self::Dropoff,
                "PICKUP" => Self::Pickup,
                "PARKING" => Self::Parking,
                _ => Self::UnknownValue(usage::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// Landmarks are used to communicate where the destination is or help with
/// arriving at the destination.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Landmark {
    /// A human-readable description of how the destination relates to the
    /// landmark. For example: "Near the Empire State Building" or "Across from
    /// the White House".
    pub relational_description: std::option::Option<google_cloud_type::model::LocalizedText>,

    /// Tags that describe how the landmark can be used in the context of the
    /// destination.
    pub tags: std::vec::Vec<crate::model::landmark::Tag>,

    /// Output only. The straight-line distance from this landmark to the
    /// destination in meters.
    pub straight_line_distance_meters: f64,

    /// Output only. The road-network distance from this landmark to the
    /// destination in meters.
    pub travel_distance_meters: f64,

    /// The landmark.
    pub landmark: std::option::Option<crate::model::landmark::Landmark>,

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

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

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

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

    /// Sets the value of [tags][crate::model::Landmark::tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::Landmark;
    /// use google_maps_geocode_v4::model::landmark::Tag;
    /// let x = Landmark::new().set_tags([
    ///     Tag::Address,
    ///     Tag::Arrival,
    /// ]);
    /// ```
    pub fn set_tags<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::landmark::Tag>,
    {
        use std::iter::Iterator;
        self.tags = v.into_iter().map(|i| i.into()).collect();
        self
    }

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

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

    /// Sets the value of [landmark][crate::model::Landmark::landmark].
    ///
    /// Note that all the setters affecting `landmark` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::Landmark;
    /// use google_maps_geocode_v4::model::PlaceView;
    /// let x = Landmark::new().set_landmark(Some(
    ///     google_maps_geocode_v4::model::landmark::Landmark::Place(PlaceView::default().into())));
    /// ```
    pub fn set_landmark<
        T: std::convert::Into<std::option::Option<crate::model::landmark::Landmark>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.landmark = v.into();
        self
    }

    /// The value of [landmark][crate::model::Landmark::landmark]
    /// if it holds a `Place`, `None` if the field is not set or
    /// holds a different branch.
    pub fn place(&self) -> std::option::Option<&std::boxed::Box<crate::model::PlaceView>> {
        #[allow(unreachable_patterns)]
        self.landmark.as_ref().and_then(|v| match v {
            crate::model::landmark::Landmark::Place(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [landmark][crate::model::Landmark::landmark]
    /// to hold a `Place`.
    ///
    /// Note that all the setters affecting `landmark` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::Landmark;
    /// use google_maps_geocode_v4::model::PlaceView;
    /// let x = Landmark::new().set_place(PlaceView::default()/* use setters */);
    /// assert!(x.place().is_some());
    /// ```
    pub fn set_place<T: std::convert::Into<std::boxed::Box<crate::model::PlaceView>>>(
        mut self,
        v: T,
    ) -> Self {
        self.landmark =
            std::option::Option::Some(crate::model::landmark::Landmark::Place(v.into()));
        self
    }
}

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

/// Defines additional types related to [Landmark].
pub mod landmark {
    #[allow(unused_imports)]
    use super::*;

    /// The list of all possible tags that describe how a landmark can be used in
    /// the context of a destination.
    ///
    /// If an address has both the `ADDRESS` and `ARRIVAL` tags, it means the
    /// landmark is both locally prominent and close to the destination.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Tag {
        /// Not used.
        Unspecified,
        /// A locally prominent place that can be used to identify the general
        /// location of the destination. Typically within a few hundred meters of the
        /// destination. These are similar to the landmarks returned by the
        /// Address Descriptors feature of the Geocoding API:
        /// <https://developers.google.com/maps/documentation/geocoding/address-descriptors/requests-address-descriptors>.
        Address,
        /// A place that can be used to help arrive at the destination. Useful for
        /// navigation once you are close to the destination. For example, this
        /// landmark might be a place that is across the street from the destination.
        /// A landmark with this tag is typically closer to the destination than
        /// landmarks with the `ADDRESS` tag.
        Arrival,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Tag::value] or
        /// [Tag::name].
        UnknownValue(tag::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for Tag {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Address,
                2 => Self::Arrival,
                _ => Self::UnknownValue(tag::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Tag {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TAG_UNSPECIFIED" => Self::Unspecified,
                "ADDRESS" => Self::Address,
                "ARRIVAL" => Self::Arrival,
                _ => Self::UnknownValue(tag::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

    /// The landmark.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Landmark {
        /// The place that represents this landmark.
        Place(std::boxed::Box<crate::model::PlaceView>),
    }
}

/// Request message for GeocodeService.GeocodeAddress.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GeocodeAddressRequest {
    /// Optional. The region to search. This location serves as a bias which means
    /// results around the given location are preferred.
    pub location_bias: std::option::Option<crate::model::geocode_address_request::LocationBias>,

    /// Optional. Language in which the results should be returned.
    pub language_code: std::string::String,

    /// Optional. Region code. The region code, specified as a ccTLD ("top-level
    /// domain") two-character value. The parameter affects results based on
    /// applicable law. This parameter will also influence, but not fully restrict,
    /// results from the service.
    pub region_code: std::string::String,

    /// The address to geocode.
    pub address_input: std::option::Option<crate::model::geocode_address_request::AddressInput>,

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

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

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

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

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

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

    /// Sets the value of [address_input][crate::model::GeocodeAddressRequest::address_input].
    ///
    /// Note that all the setters affecting `address_input` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::GeocodeAddressRequest;
    /// use google_maps_geocode_v4::model::geocode_address_request::AddressInput;
    /// let x = GeocodeAddressRequest::new().set_address_input(Some(AddressInput::AddressQuery("example".to_string())));
    /// ```
    pub fn set_address_input<
        T: std::convert::Into<
                std::option::Option<crate::model::geocode_address_request::AddressInput>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.address_input = v.into();
        self
    }

    /// The value of [address_input][crate::model::GeocodeAddressRequest::address_input]
    /// if it holds a `AddressQuery`, `None` if the field is not set or
    /// holds a different branch.
    pub fn address_query(&self) -> std::option::Option<&std::string::String> {
        #[allow(unreachable_patterns)]
        self.address_input.as_ref().and_then(|v| match v {
            crate::model::geocode_address_request::AddressInput::AddressQuery(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [address_input][crate::model::GeocodeAddressRequest::address_input]
    /// to hold a `AddressQuery`.
    ///
    /// Note that all the setters affecting `address_input` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::GeocodeAddressRequest;
    /// let x = GeocodeAddressRequest::new().set_address_query("example");
    /// assert!(x.address_query().is_some());
    /// assert!(x.address().is_none());
    /// ```
    pub fn set_address_query<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.address_input = std::option::Option::Some(
            crate::model::geocode_address_request::AddressInput::AddressQuery(v.into()),
        );
        self
    }

    /// The value of [address_input][crate::model::GeocodeAddressRequest::address_input]
    /// if it holds a `Address`, `None` if the field is not set or
    /// holds a different branch.
    pub fn address(
        &self,
    ) -> std::option::Option<&std::boxed::Box<google_cloud_type::model::PostalAddress>> {
        #[allow(unreachable_patterns)]
        self.address_input.as_ref().and_then(|v| match v {
            crate::model::geocode_address_request::AddressInput::Address(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [address_input][crate::model::GeocodeAddressRequest::address_input]
    /// to hold a `Address`.
    ///
    /// Note that all the setters affecting `address_input` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::GeocodeAddressRequest;
    /// use google_cloud_type::model::PostalAddress;
    /// let x = GeocodeAddressRequest::new().set_address(PostalAddress::default()/* use setters */);
    /// assert!(x.address().is_some());
    /// assert!(x.address_query().is_none());
    /// ```
    pub fn set_address<
        T: std::convert::Into<std::boxed::Box<google_cloud_type::model::PostalAddress>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.address_input = std::option::Option::Some(
            crate::model::geocode_address_request::AddressInput::Address(v.into()),
        );
        self
    }
}

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

/// Defines additional types related to [GeocodeAddressRequest].
pub mod geocode_address_request {
    #[allow(unused_imports)]
    use super::*;

    /// The region to search. This location serves as a bias which means results
    /// around the given location are preferred.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct LocationBias {
        /// Types of location bias.
        pub r#type: std::option::Option<crate::model::geocode_address_request::location_bias::Type>,

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

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

        /// Sets the value of [r#type][crate::model::geocode_address_request::LocationBias::type].
        ///
        /// Note that all the setters affecting `r#type` are mutually
        /// exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_geocode_v4::model::geocode_address_request::LocationBias;
        /// use google_geo_type::model::Viewport;
        /// let x = LocationBias::new().set_type(Some(
        ///     google_maps_geocode_v4::model::geocode_address_request::location_bias::Type::Rectangle(Viewport::default().into())));
        /// ```
        pub fn set_type<
            T: std::convert::Into<
                    std::option::Option<crate::model::geocode_address_request::location_bias::Type>,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.r#type = v.into();
            self
        }

        /// The value of [r#type][crate::model::geocode_address_request::LocationBias::r#type]
        /// if it holds a `Rectangle`, `None` if the field is not set or
        /// holds a different branch.
        pub fn rectangle(
            &self,
        ) -> std::option::Option<&std::boxed::Box<google_geo_type::model::Viewport>> {
            #[allow(unreachable_patterns)]
            self.r#type.as_ref().and_then(|v| match v {
                crate::model::geocode_address_request::location_bias::Type::Rectangle(v) => {
                    std::option::Option::Some(v)
                }
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [r#type][crate::model::geocode_address_request::LocationBias::r#type]
        /// to hold a `Rectangle`.
        ///
        /// Note that all the setters affecting `r#type` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_geocode_v4::model::geocode_address_request::LocationBias;
        /// use google_geo_type::model::Viewport;
        /// let x = LocationBias::new().set_rectangle(Viewport::default()/* use setters */);
        /// assert!(x.rectangle().is_some());
        /// ```
        pub fn set_rectangle<
            T: std::convert::Into<std::boxed::Box<google_geo_type::model::Viewport>>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.r#type = std::option::Option::Some(
                crate::model::geocode_address_request::location_bias::Type::Rectangle(v.into()),
            );
            self
        }
    }

    impl wkt::message::Message for LocationBias {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.geocode.v4.GeocodeAddressRequest.LocationBias"
        }
    }

    /// Defines additional types related to [LocationBias].
    pub mod location_bias {
        #[allow(unused_imports)]
        use super::*;

        /// Types of location bias.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Type {
            /// A rectangular box defined by northeast and southwest corner.
            /// `rectangle.high()` must be the northeast point of the rectangle
            /// viewport. `rectangle.low()` must be the southwest point of the
            /// rectangle viewport. `rectangle.low().latitude()` cannot be greater than
            /// `rectangle.high().latitude()`. This will result in an empty latitude
            /// range. A rectangle viewport cannot be wider than 180 degrees.
            Rectangle(std::boxed::Box<google_geo_type::model::Viewport>),
        }
    }

    /// The address to geocode.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum AddressInput {
        /// The unstructured address to geocode.
        AddressQuery(std::string::String),
        /// The structured address to geocode in postal address format.
        Address(std::boxed::Box<google_cloud_type::model::PostalAddress>),
    }
}

/// Request message for GeocodeService.GeocodeLocation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GeocodeLocationRequest {
    /// Optional. Language in which the results should be returned.
    pub language_code: std::string::String,

    /// Optional. Region code. The region code, specified as a ccTLD ("top-level
    /// domain") two-character value. The parameter affects results based on
    /// applicable law.
    pub region_code: std::string::String,

    /// Optional. A set of type tags to restrict the results. Results that do not
    /// have any of the specified types are removed.
    ///
    /// For the complete list of possible values, see Table A and Table B at
    /// <https://developers.google.com/maps/documentation/places/web-service/place-types>.
    pub types: std::vec::Vec<std::string::String>,

    /// Optional. A filter of one or more location granularity enums.
    pub granularity: std::vec::Vec<crate::model::geocode_result::Granularity>,

    /// The location to geocode.
    pub location_input: std::option::Option<crate::model::geocode_location_request::LocationInput>,

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

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

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

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

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

    /// Sets the value of [granularity][crate::model::GeocodeLocationRequest::granularity].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::GeocodeLocationRequest;
    /// use google_maps_geocode_v4::model::geocode_result::Granularity;
    /// let x = GeocodeLocationRequest::new().set_granularity([
    ///     Granularity::Rooftop,
    ///     Granularity::RangeInterpolated,
    ///     Granularity::GeometricCenter,
    /// ]);
    /// ```
    pub fn set_granularity<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::geocode_result::Granularity>,
    {
        use std::iter::Iterator;
        self.granularity = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [location_input][crate::model::GeocodeLocationRequest::location_input].
    ///
    /// Note that all the setters affecting `location_input` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::GeocodeLocationRequest;
    /// use google_maps_geocode_v4::model::geocode_location_request::LocationInput;
    /// let x = GeocodeLocationRequest::new().set_location_input(Some(LocationInput::LocationQuery("example".to_string())));
    /// ```
    pub fn set_location_input<
        T: std::convert::Into<
                std::option::Option<crate::model::geocode_location_request::LocationInput>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.location_input = v.into();
        self
    }

    /// The value of [location_input][crate::model::GeocodeLocationRequest::location_input]
    /// if it holds a `LocationQuery`, `None` if the field is not set or
    /// holds a different branch.
    pub fn location_query(&self) -> std::option::Option<&std::string::String> {
        #[allow(unreachable_patterns)]
        self.location_input.as_ref().and_then(|v| match v {
            crate::model::geocode_location_request::LocationInput::LocationQuery(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [location_input][crate::model::GeocodeLocationRequest::location_input]
    /// to hold a `LocationQuery`.
    ///
    /// Note that all the setters affecting `location_input` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::GeocodeLocationRequest;
    /// let x = GeocodeLocationRequest::new().set_location_query("example");
    /// assert!(x.location_query().is_some());
    /// assert!(x.location().is_none());
    /// ```
    pub fn set_location_query<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.location_input = std::option::Option::Some(
            crate::model::geocode_location_request::LocationInput::LocationQuery(v.into()),
        );
        self
    }

    /// The value of [location_input][crate::model::GeocodeLocationRequest::location_input]
    /// if it holds a `Location`, `None` if the field is not set or
    /// holds a different branch.
    pub fn location(
        &self,
    ) -> std::option::Option<&std::boxed::Box<google_cloud_type::model::LatLng>> {
        #[allow(unreachable_patterns)]
        self.location_input.as_ref().and_then(|v| match v {
            crate::model::geocode_location_request::LocationInput::Location(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [location_input][crate::model::GeocodeLocationRequest::location_input]
    /// to hold a `Location`.
    ///
    /// Note that all the setters affecting `location_input` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::GeocodeLocationRequest;
    /// use google_cloud_type::model::LatLng;
    /// let x = GeocodeLocationRequest::new().set_location(LatLng::default()/* use setters */);
    /// assert!(x.location().is_some());
    /// assert!(x.location_query().is_none());
    /// ```
    pub fn set_location<
        T: std::convert::Into<std::boxed::Box<google_cloud_type::model::LatLng>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.location_input = std::option::Option::Some(
            crate::model::geocode_location_request::LocationInput::Location(v.into()),
        );
        self
    }
}

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

/// Defines additional types related to [GeocodeLocationRequest].
pub mod geocode_location_request {
    #[allow(unused_imports)]
    use super::*;

    /// The location to geocode.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum LocationInput {
        /// The location in the format of "lat,lng" string. For example,
        /// "64.7611872,-18.4705364".
        LocationQuery(std::string::String),
        /// The location in the structured format.
        Location(std::boxed::Box<google_cloud_type::model::LatLng>),
    }
}

/// Request message for GeocodeService.GeocodePlace.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GeocodePlaceRequest {
    /// Required. Place identifier to geocode in the format of places/{place}.
    pub place: std::string::String,

    /// Optional. Language in which the results should be returned.
    pub language_code: std::string::String,

    /// Optional. Region code. The region code, specified as a ccTLD ("top-level
    /// domain") two-character value. The parameter affects results based on
    /// applicable law.
    pub region_code: std::string::String,

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

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

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

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

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

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

/// Plus code (<http://plus.codes>) is a location reference with two formats:
/// global code defining a 14mx14m (1/8000th of a degree) or smaller rectangle,
/// and compound code, replacing the prefix with a reference location.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PlusCode {
    /// Place's global (full) code, such as "9FWM33GV+HQ", representing an
    /// 1/8000 by 1/8000 degree area (~14 by 14 meters).
    pub global_code: std::string::String,

    /// Place's compound code, such as "33GV+HQ, Ramberg, Norway", containing
    /// the suffix of the global code and replacing the prefix with a formatted
    /// name of a reference entity.
    pub compound_code: std::string::String,

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

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

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

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

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

/// A geocode result contains geographic information about a place.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GeocodeResult {
    /// This Place's resource name, in `places/{placeId}` format.  Can be used to
    /// look up the Place.
    pub place: std::string::String,

    /// The unique identifier of a place.
    pub place_id: std::string::String,

    /// The latlng of this address.
    pub location: std::option::Option<google_cloud_type::model::LatLng>,

    /// The granularity of the location.
    pub granularity: crate::model::geocode_result::Granularity,

    /// A viewport suitable for displaying the geocode result.
    pub viewport: std::option::Option<google_geo_type::model::Viewport>,

    /// A bounding box for the address.
    pub bounds: std::option::Option<google_geo_type::model::Viewport>,

    /// The one line formatted address.
    pub formatted_address: std::string::String,

    /// The address in postal address format.
    pub postal_address: std::option::Option<google_cloud_type::model::PostalAddress>,

    /// Repeated components for each locality level.
    pub address_components: std::vec::Vec<crate::model::geocode_result::AddressComponent>,

    /// Complete list of localities contained in the postal code.
    ///
    /// This is only populated when the result is of type "postal_code".
    pub postal_code_localities: std::vec::Vec<google_cloud_type::model::LocalizedText>,

    /// A set of type tags for this result. For
    /// example, "political" and "administrative_area".
    ///
    /// For the complete list of possible values, see Table A and Table B at
    /// <https://developers.google.com/maps/documentation/places/web-service/place-types>.
    pub types: std::vec::Vec<std::string::String>,

    /// Plus code of the location in this geocode.
    pub plus_code: std::option::Option<crate::model::PlusCode>,

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

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

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

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

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

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

    /// Sets the value of [granularity][crate::model::GeocodeResult::granularity].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_geocode_v4::model::GeocodeResult;
    /// use google_maps_geocode_v4::model::geocode_result::Granularity;
    /// let x0 = GeocodeResult::new().set_granularity(Granularity::Rooftop);
    /// let x1 = GeocodeResult::new().set_granularity(Granularity::RangeInterpolated);
    /// let x2 = GeocodeResult::new().set_granularity(Granularity::GeometricCenter);
    /// ```
    pub fn set_granularity<T: std::convert::Into<crate::model::geocode_result::Granularity>>(
        mut self,
        v: T,
    ) -> Self {
        self.granularity = v.into();
        self
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Defines additional types related to [GeocodeResult].
pub mod geocode_result {
    #[allow(unused_imports)]
    use super::*;

    /// The structured components that form the formatted address, if this
    /// information is available.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct AddressComponent {
        /// The full text description or name of the address component. For example,
        /// an address component for the country Australia may have a long name of
        /// "Australia".
        pub long_text: std::string::String,

        /// An abbreviated textual name for the address component, if available. For
        /// example, an address component for the country of Australia may have a
        /// short name of "AU".
        pub short_text: std::string::String,

        /// An array indicating the type(s) of the address component.
        ///
        /// See
        /// <https://developers.google.com/maps/documentation/geocoding/requests-geocoding#Types>
        /// for more details.
        pub types: std::vec::Vec<std::string::String>,

        /// The language used to format this component, in CLDR notation.
        pub language_code: std::string::String,

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

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

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

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

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

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

    impl wkt::message::Message for AddressComponent {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.geocode.v4.GeocodeResult.AddressComponent"
        }
    }

    /// The granularity of the location.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Granularity {
        /// Do not use.
        Unspecified,
        /// The non-interpolated location of an actual plot of land corresponding
        /// to the matched address.
        Rooftop,
        /// Interpolated from a range of street numbers. For example, if we know
        /// that a segment of Amphitheatre Pkwy contains numbers 1600 - 1699, then
        /// 1650 might be placed halfway between its endpoints.
        RangeInterpolated,
        /// The geometric center of a feature for which we have polygonal data.
        GeometricCenter,
        /// Everything else.
        Approximate,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Granularity::value] or
        /// [Granularity::name].
        UnknownValue(granularity::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for Granularity {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Rooftop,
                2 => Self::RangeInterpolated,
                3 => Self::GeometricCenter,
                4 => Self::Approximate,
                _ => Self::UnknownValue(granularity::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Granularity {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "GRANULARITY_UNSPECIFIED" => Self::Unspecified,
                "ROOFTOP" => Self::Rooftop,
                "RANGE_INTERPOLATED" => Self::RangeInterpolated,
                "GEOMETRIC_CENTER" => Self::GeometricCenter,
                "APPROXIMATE" => Self::Approximate,
                _ => Self::UnknownValue(granularity::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// Response message for
/// [GeocodeService.GeocodeAddress][google.maps.geocode.v4.GeocodeService.GeocodeAddress].
///
/// [google.maps.geocode.v4.GeocodeService.GeocodeAddress]: crate::client::GeocodeService::geocode_address
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GeocodeAddressResponse {
    /// The geocoding result.
    pub results: std::vec::Vec<crate::model::GeocodeResult>,

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

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

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

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

/// Response message for
/// [GeocodeService.GeocodeLocation][google.maps.geocode.v4.GeocodeService.GeocodeLocation].
///
/// [google.maps.geocode.v4.GeocodeService.GeocodeLocation]: crate::client::GeocodeService::geocode_location
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GeocodeLocationResponse {
    /// The geocoding result.
    pub results: std::vec::Vec<crate::model::GeocodeResult>,

    /// Plus code of the location in the request.
    pub plus_code: std::option::Option<crate::model::PlusCode>,

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

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

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

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

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

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