// This file is @generated by prost-build.
/// A relational description of a location. Includes a ranked set of nearby
/// landmarks and precise containing areas and their relationship to the target
/// location.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddressDescriptor {
    /// A ranked list of nearby landmarks. The most recognizable and nearby
    /// landmarks are ranked first.
    #[prost(message, repeated, tag = "1")]
    pub landmarks: ::prost::alloc::vec::Vec<address_descriptor::Landmark>,
    /// A ranked list of containing or adjacent areas. The most recognizable and
    /// precise areas are ranked first.
    #[prost(message, repeated, tag = "2")]
    pub areas: ::prost::alloc::vec::Vec<address_descriptor::Area>,
}
/// Nested message and enum types in `AddressDescriptor`.
pub mod address_descriptor {
    /// Basic landmark information and the landmark's relationship with the
    /// target location.
    ///
    /// Landmarks are prominent places that can be used to describe a location.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Landmark {
        /// The landmark's resource name.
        #[prost(string, tag = "1")]
        pub name: ::prost::alloc::string::String,
        /// The landmark's place id.
        #[prost(string, tag = "2")]
        pub place_id: ::prost::alloc::string::String,
        /// The landmark's display name.
        #[prost(message, optional, tag = "3")]
        pub display_name: ::core::option::Option<
            super::super::super::super::r#type::LocalizedText,
        >,
        /// A set of type tags for this landmark. For a complete list of possible
        /// values, see
        /// <https://developers.google.com/maps/documentation/places/web-service/place-types.>
        #[prost(string, repeated, tag = "4")]
        pub types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Defines the spatial relationship between the target location and the
        /// landmark.
        #[prost(enumeration = "landmark::SpatialRelationship", tag = "5")]
        pub spatial_relationship: i32,
        /// The straight line distance, in meters, between the center point of the
        /// target and the center point of the landmark. In some situations, this
        /// value can be longer than `travel_distance_meters`.
        #[prost(float, tag = "6")]
        pub straight_line_distance_meters: f32,
        /// The travel distance, in meters, along the road network from the target to
        /// the landmark, if known. This value does not take into account the mode of
        /// transportation, such as walking, driving, or biking.
        #[prost(float, optional, tag = "7")]
        pub travel_distance_meters: ::core::option::Option<f32>,
    }
    /// Nested message and enum types in `Landmark`.
    pub mod landmark {
        /// Defines the spatial relationship between the target location and the
        /// landmark.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum SpatialRelationship {
            /// This is the default relationship when nothing more specific below
            /// applies.
            Near = 0,
            /// The landmark has a spatial geometry and the target is within its
            /// bounds.
            Within = 1,
            /// The target is directly adjacent to the landmark.
            Beside = 2,
            /// The target is directly opposite the landmark on the other side of the
            /// road.
            AcrossTheRoad = 3,
            /// On the same route as the landmark but not besides or across.
            DownTheRoad = 4,
            /// Not on the same route as the landmark but a single turn away.
            AroundTheCorner = 5,
            /// Close to the landmark's structure but further away from its street
            /// entrances.
            Behind = 6,
        }
        impl SpatialRelationship {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Near => "NEAR",
                    Self::Within => "WITHIN",
                    Self::Beside => "BESIDE",
                    Self::AcrossTheRoad => "ACROSS_THE_ROAD",
                    Self::DownTheRoad => "DOWN_THE_ROAD",
                    Self::AroundTheCorner => "AROUND_THE_CORNER",
                    Self::Behind => "BEHIND",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "NEAR" => Some(Self::Near),
                    "WITHIN" => Some(Self::Within),
                    "BESIDE" => Some(Self::Beside),
                    "ACROSS_THE_ROAD" => Some(Self::AcrossTheRoad),
                    "DOWN_THE_ROAD" => Some(Self::DownTheRoad),
                    "AROUND_THE_CORNER" => Some(Self::AroundTheCorner),
                    "BEHIND" => Some(Self::Behind),
                    _ => None,
                }
            }
        }
    }
    /// Area information and the area's relationship with the target location.
    ///
    /// Areas includes precise sublocality, neighborhoods, and large compounds that
    /// are useful for describing a location.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Area {
        /// The area's resource name.
        #[prost(string, tag = "1")]
        pub name: ::prost::alloc::string::String,
        /// The area's place id.
        #[prost(string, tag = "2")]
        pub place_id: ::prost::alloc::string::String,
        /// The area's display name.
        #[prost(message, optional, tag = "3")]
        pub display_name: ::core::option::Option<
            super::super::super::super::r#type::LocalizedText,
        >,
        /// Defines the spatial relationship between the target location and the
        /// area.
        #[prost(enumeration = "area::Containment", tag = "4")]
        pub containment: i32,
    }
    /// Nested message and enum types in `Area`.
    pub mod area {
        /// Defines the spatial relationship between the target location and the
        /// area.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Containment {
            /// The containment is unspecified.
            Unspecified = 0,
            /// The target location is within the area region, close to the
            /// center.
            Within = 1,
            /// The target location is within the area region, close to the edge.
            Outskirts = 2,
            /// The target location is outside the area region, but close by.
            Near = 3,
        }
        impl Containment {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Unspecified => "CONTAINMENT_UNSPECIFIED",
                    Self::Within => "WITHIN",
                    Self::Outskirts => "OUTSKIRTS",
                    Self::Near => "NEAR",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "CONTAINMENT_UNSPECIFIED" => Some(Self::Unspecified),
                    "WITHIN" => Some(Self::Within),
                    "OUTSKIRTS" => Some(Self::Outskirts),
                    "NEAR" => Some(Self::Near),
                    _ => None,
                }
            }
        }
    }
}
/// Information about the author of the UGC data. Used in
/// \[Photo\]\[google.maps.places.v1.Photo\], and
/// \[Review\]\[google.maps.places.v1.Review\].
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AuthorAttribution {
    /// Name of the author of the \[Photo\]\[google.maps.places.v1.Photo\] or
    /// \[Review\]\[google.maps.places.v1.Review\].
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of the author of the \[Photo\]\[google.maps.places.v1.Photo\] or
    /// \[Review\]\[google.maps.places.v1.Review\].
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// Profile photo URI of the author of the
    /// \[Photo\]\[google.maps.places.v1.Photo\] or
    /// \[Review\]\[google.maps.places.v1.Review\].
    #[prost(string, tag = "3")]
    pub photo_uri: ::prost::alloc::string::String,
}
/// Information about a review of a place.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Review {
    /// A reference representing this place review which may be used to look up
    /// this place review again (also called the API "resource" name:
    /// `places/{place_id}/reviews/{review}`).
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A string of formatted recent time, expressing the review time relative
    /// to the current time in a form appropriate for the language and country.
    #[prost(string, tag = "2")]
    pub relative_publish_time_description: ::prost::alloc::string::String,
    /// The localized text of the review.
    #[prost(message, optional, tag = "9")]
    pub text: ::core::option::Option<super::super::super::r#type::LocalizedText>,
    /// The review text in its original language.
    #[prost(message, optional, tag = "12")]
    pub original_text: ::core::option::Option<
        super::super::super::r#type::LocalizedText,
    >,
    /// A number between 1.0 and 5.0, also called the number of stars.
    #[prost(double, tag = "7")]
    pub rating: f64,
    /// This review's author.
    #[prost(message, optional, tag = "13")]
    pub author_attribution: ::core::option::Option<AuthorAttribution>,
    /// Timestamp for the review.
    #[prost(message, optional, tag = "14")]
    pub publish_time: ::core::option::Option<::prost_types::Timestamp>,
    /// A link where users can flag a problem with the review.
    #[prost(string, tag = "15")]
    pub flag_content_uri: ::prost::alloc::string::String,
    /// A link to show the review on Google Maps.
    #[prost(string, tag = "16")]
    pub google_maps_uri: ::prost::alloc::string::String,
}
/// Experimental: See
/// <https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative>
/// for more details.
///
/// Reference that the generative content is related to.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct References {
    /// Reviews that serve as references.
    #[prost(message, repeated, tag = "1")]
    pub reviews: ::prost::alloc::vec::Vec<Review>,
    /// The list of resource names of the referenced places. This name can be used
    /// in other APIs that accept Place resource names.
    #[prost(string, repeated, tag = "2")]
    pub places: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// A block of content that can be served individually.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContentBlock {
    /// The topic of the content, for example "overview" or "restaurant".
    #[prost(string, tag = "1")]
    pub topic: ::prost::alloc::string::String,
    /// Content related to the topic.
    #[prost(message, optional, tag = "2")]
    pub content: ::core::option::Option<super::super::super::r#type::LocalizedText>,
    /// Experimental: See
    /// <https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative>
    /// for more details.
    ///
    /// References that are related to this block of content.
    #[prost(message, optional, tag = "3")]
    pub references: ::core::option::Option<References>,
}
/// Information about a photo of a place.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Photo {
    /// Identifier. A reference representing this place photo which may be used to
    /// look up this place photo again (also called the API "resource" name:
    /// `places/{place_id}/photos/{photo}`).
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The maximum available width, in pixels.
    #[prost(int32, tag = "2")]
    pub width_px: i32,
    /// The maximum available height, in pixels.
    #[prost(int32, tag = "3")]
    pub height_px: i32,
    /// This photo's authors.
    #[prost(message, repeated, tag = "4")]
    pub author_attributions: ::prost::alloc::vec::Vec<AuthorAttribution>,
    /// A link where users can flag a problem with the photo.
    #[prost(string, tag = "5")]
    pub flag_content_uri: ::prost::alloc::string::String,
    /// A link to show the photo on Google Maps.
    #[prost(string, tag = "6")]
    pub google_maps_uri: ::prost::alloc::string::String,
}
/// Experimental: See
/// <https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative>
/// for more details.
///
/// Content that is contextual to the place query.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContextualContent {
    /// List of reviews about this place, contexual to the place query.
    #[prost(message, repeated, tag = "1")]
    pub reviews: ::prost::alloc::vec::Vec<Review>,
    /// Information (including references) about photos of this place, contexual to
    /// the place query.
    #[prost(message, repeated, tag = "2")]
    pub photos: ::prost::alloc::vec::Vec<Photo>,
    /// Experimental: See
    /// <https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative>
    /// for more details.
    ///
    /// Justifications for the place.
    #[prost(message, repeated, tag = "3")]
    pub justifications: ::prost::alloc::vec::Vec<contextual_content::Justification>,
}
/// Nested message and enum types in `ContextualContent`.
pub mod contextual_content {
    /// Experimental: See
    /// <https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative>
    /// for more details.
    ///
    /// Justifications for the place. Justifications answers the question of why a
    /// place could interest an end user.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Justification {
        #[prost(oneof = "justification::Justification", tags = "1, 2")]
        pub justification: ::core::option::Option<justification::Justification>,
    }
    /// Nested message and enum types in `Justification`.
    pub mod justification {
        /// Experimental: See
        /// <https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative>
        /// for more details.
        ///
        /// User review justifications. This highlights a section of the user review
        /// that would interest an end user. For instance, if the search query is
        /// "firewood pizza", the review justification highlights the text relevant
        /// to the search query.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ReviewJustification {
            #[prost(message, optional, tag = "1")]
            pub highlighted_text: ::core::option::Option<
                review_justification::HighlightedText,
            >,
            /// The review that the highlighted text is generated from.
            #[prost(message, optional, tag = "2")]
            pub review: ::core::option::Option<super::super::Review>,
        }
        /// Nested message and enum types in `ReviewJustification`.
        pub mod review_justification {
            /// The text highlighted by the justification. This is a subset of the
            /// review itself. The exact word to highlight is marked by the
            /// HighlightedTextRange. There could be several words in the text being
            /// highlighted.
            #[derive(Clone, PartialEq, ::prost::Message)]
            pub struct HighlightedText {
                #[prost(string, tag = "1")]
                pub text: ::prost::alloc::string::String,
                /// The list of the ranges of the highlighted text.
                #[prost(message, repeated, tag = "2")]
                pub highlighted_text_ranges: ::prost::alloc::vec::Vec<
                    highlighted_text::HighlightedTextRange,
                >,
            }
            /// Nested message and enum types in `HighlightedText`.
            pub mod highlighted_text {
                /// The range of highlighted text.
                #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
                pub struct HighlightedTextRange {
                    #[prost(int32, tag = "1")]
                    pub start_index: i32,
                    #[prost(int32, tag = "2")]
                    pub end_index: i32,
                }
            }
        }
        /// Experimental: See
        /// <https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative>
        /// for more details.
        /// BusinessAvailabilityAttributes justifications. This shows some attributes
        /// a business has that could interest an end user.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct BusinessAvailabilityAttributesJustification {
            /// If a place provides takeout.
            #[prost(bool, tag = "1")]
            pub takeout: bool,
            /// If a place provides delivery.
            #[prost(bool, tag = "2")]
            pub delivery: bool,
            /// If a place provides dine-in.
            #[prost(bool, tag = "3")]
            pub dine_in: bool,
        }
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Justification {
            /// Experimental: See
            /// <https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative>
            /// for more details.
            #[prost(message, tag = "1")]
            ReviewJustification(ReviewJustification),
            /// Experimental: See
            /// <https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative>
            /// for more details.
            #[prost(message, tag = "2")]
            BusinessAvailabilityAttributesJustification(
                BusinessAvailabilityAttributesJustification,
            ),
        }
    }
}
/// Information about the EV Charge Station hosted in Place.
/// Terminology follows
/// <https://afdc.energy.gov/fuels/electricity_infrastructure.html> One port
/// could charge one car at a time. One port has one or more connectors. One
/// station has one or more ports.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EvChargeOptions {
    /// Number of connectors at this station. However, because some ports can have
    /// multiple connectors but only be able to charge one car at a time (e.g.) the
    /// number of connectors may be greater than the total number of cars which can
    /// charge simultaneously.
    #[prost(int32, tag = "1")]
    pub connector_count: i32,
    /// A list of EV charging connector aggregations that contain connectors of the
    /// same type and same charge rate.
    #[prost(message, repeated, tag = "2")]
    pub connector_aggregation: ::prost::alloc::vec::Vec<
        ev_charge_options::ConnectorAggregation,
    >,
}
/// Nested message and enum types in `EVChargeOptions`.
pub mod ev_charge_options {
    /// EV charging information grouped by \[type, max_charge_rate_kw\].
    /// Shows EV charge aggregation of connectors that have the same type and max
    /// charge rate in kw.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct ConnectorAggregation {
        /// The connector type of this aggregation.
        #[prost(enumeration = "super::EvConnectorType", tag = "1")]
        pub r#type: i32,
        /// The static max charging rate in kw of each connector in the aggregation.
        #[prost(double, tag = "2")]
        pub max_charge_rate_kw: f64,
        /// Number of connectors in this aggregation.
        #[prost(int32, tag = "3")]
        pub count: i32,
        /// Number of connectors in this aggregation that are currently available.
        #[prost(int32, optional, tag = "4")]
        pub available_count: ::core::option::Option<i32>,
        /// Number of connectors in this aggregation that are currently out of
        /// service.
        #[prost(int32, optional, tag = "5")]
        pub out_of_service_count: ::core::option::Option<i32>,
        /// The timestamp when the connector availability information in this
        /// aggregation was last updated.
        #[prost(message, optional, tag = "6")]
        pub availability_last_update_time: ::core::option::Option<
            ::prost_types::Timestamp,
        >,
    }
}
/// See <http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=6872107> for
/// additional information/context on EV charging connector types.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum EvConnectorType {
    /// Unspecified connector.
    Unspecified = 0,
    /// Other connector types.
    Other = 1,
    /// J1772 type 1 connector.
    J1772 = 2,
    /// IEC 62196 type 2 connector. Often referred to as MENNEKES.
    Type2 = 3,
    /// CHAdeMO type connector.
    Chademo = 4,
    /// Combined Charging System (AC and DC). Based on SAE.
    /// Type-1 J-1772 connector
    CcsCombo1 = 5,
    /// Combined Charging System (AC and DC). Based on Type-2
    /// Mennekes connector
    CcsCombo2 = 6,
    /// The generic TESLA connector. This is NACS in the North America but can be
    /// non-NACS in other parts of the world (e.g. CCS Combo 2 (CCS2) or GB/T).
    /// This value is less representative of an actual connector type, and more
    /// represents the ability to charge a Tesla brand vehicle at a Tesla owned
    /// charging station.
    Tesla = 7,
    /// GB/T type corresponds to the GB/T standard in China. This type covers all
    /// GB_T types.
    UnspecifiedGbT = 8,
    /// Unspecified wall outlet.
    UnspecifiedWallOutlet = 9,
    /// The North American Charging System (NACS), standardized as SAE J3400.
    Nacs = 10,
}
impl EvConnectorType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "EV_CONNECTOR_TYPE_UNSPECIFIED",
            Self::Other => "EV_CONNECTOR_TYPE_OTHER",
            Self::J1772 => "EV_CONNECTOR_TYPE_J1772",
            Self::Type2 => "EV_CONNECTOR_TYPE_TYPE_2",
            Self::Chademo => "EV_CONNECTOR_TYPE_CHADEMO",
            Self::CcsCombo1 => "EV_CONNECTOR_TYPE_CCS_COMBO_1",
            Self::CcsCombo2 => "EV_CONNECTOR_TYPE_CCS_COMBO_2",
            Self::Tesla => "EV_CONNECTOR_TYPE_TESLA",
            Self::UnspecifiedGbT => "EV_CONNECTOR_TYPE_UNSPECIFIED_GB_T",
            Self::UnspecifiedWallOutlet => "EV_CONNECTOR_TYPE_UNSPECIFIED_WALL_OUTLET",
            Self::Nacs => "EV_CONNECTOR_TYPE_NACS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "EV_CONNECTOR_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "EV_CONNECTOR_TYPE_OTHER" => Some(Self::Other),
            "EV_CONNECTOR_TYPE_J1772" => Some(Self::J1772),
            "EV_CONNECTOR_TYPE_TYPE_2" => Some(Self::Type2),
            "EV_CONNECTOR_TYPE_CHADEMO" => Some(Self::Chademo),
            "EV_CONNECTOR_TYPE_CCS_COMBO_1" => Some(Self::CcsCombo1),
            "EV_CONNECTOR_TYPE_CCS_COMBO_2" => Some(Self::CcsCombo2),
            "EV_CONNECTOR_TYPE_TESLA" => Some(Self::Tesla),
            "EV_CONNECTOR_TYPE_UNSPECIFIED_GB_T" => Some(Self::UnspecifiedGbT),
            "EV_CONNECTOR_TYPE_UNSPECIFIED_WALL_OUTLET" => {
                Some(Self::UnspecifiedWallOutlet)
            }
            "EV_CONNECTOR_TYPE_NACS" => Some(Self::Nacs),
            _ => None,
        }
    }
}
/// The most recent information about fuel options in a gas station. This
/// information is updated regularly.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FuelOptions {
    /// The last known fuel price for each type of fuel this station has. There is
    /// one entry per fuel type this station has. Order is not important.
    #[prost(message, repeated, tag = "1")]
    pub fuel_prices: ::prost::alloc::vec::Vec<fuel_options::FuelPrice>,
}
/// Nested message and enum types in `FuelOptions`.
pub mod fuel_options {
    /// Fuel price information for a given type.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct FuelPrice {
        /// The type of fuel.
        #[prost(enumeration = "fuel_price::FuelType", tag = "1")]
        pub r#type: i32,
        /// The price of the fuel.
        #[prost(message, optional, tag = "2")]
        pub price: ::core::option::Option<super::super::super::super::r#type::Money>,
        /// The time the fuel price was last updated.
        #[prost(message, optional, tag = "3")]
        pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    }
    /// Nested message and enum types in `FuelPrice`.
    pub mod fuel_price {
        /// Types of fuel.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum FuelType {
            /// Unspecified fuel type.
            Unspecified = 0,
            /// Diesel fuel.
            Diesel = 1,
            /// Diesel plus fuel.
            DieselPlus = 19,
            /// Regular unleaded.
            RegularUnleaded = 2,
            /// Midgrade.
            Midgrade = 3,
            /// Premium.
            Premium = 4,
            /// SP 91.
            Sp91 = 5,
            /// SP 91 E10.
            Sp91E10 = 6,
            /// SP 92.
            Sp92 = 7,
            /// SP 95.
            Sp95 = 8,
            /// SP95 E10.
            Sp95E10 = 9,
            /// SP 98.
            Sp98 = 10,
            /// SP 99.
            Sp99 = 11,
            /// SP 100.
            Sp100 = 12,
            /// Liquefied Petroleum Gas.
            Lpg = 13,
            /// E 80.
            E80 = 14,
            /// E 85.
            E85 = 15,
            /// E 100.
            E100 = 20,
            /// Methane.
            Methane = 16,
            /// Bio-diesel.
            BioDiesel = 17,
            /// Truck diesel.
            TruckDiesel = 18,
        }
        impl FuelType {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Unspecified => "FUEL_TYPE_UNSPECIFIED",
                    Self::Diesel => "DIESEL",
                    Self::DieselPlus => "DIESEL_PLUS",
                    Self::RegularUnleaded => "REGULAR_UNLEADED",
                    Self::Midgrade => "MIDGRADE",
                    Self::Premium => "PREMIUM",
                    Self::Sp91 => "SP91",
                    Self::Sp91E10 => "SP91_E10",
                    Self::Sp92 => "SP92",
                    Self::Sp95 => "SP95",
                    Self::Sp95E10 => "SP95_E10",
                    Self::Sp98 => "SP98",
                    Self::Sp99 => "SP99",
                    Self::Sp100 => "SP100",
                    Self::Lpg => "LPG",
                    Self::E80 => "E80",
                    Self::E85 => "E85",
                    Self::E100 => "E100",
                    Self::Methane => "METHANE",
                    Self::BioDiesel => "BIO_DIESEL",
                    Self::TruckDiesel => "TRUCK_DIESEL",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "FUEL_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "DIESEL" => Some(Self::Diesel),
                    "DIESEL_PLUS" => Some(Self::DieselPlus),
                    "REGULAR_UNLEADED" => Some(Self::RegularUnleaded),
                    "MIDGRADE" => Some(Self::Midgrade),
                    "PREMIUM" => Some(Self::Premium),
                    "SP91" => Some(Self::Sp91),
                    "SP91_E10" => Some(Self::Sp91E10),
                    "SP92" => Some(Self::Sp92),
                    "SP95" => Some(Self::Sp95),
                    "SP95_E10" => Some(Self::Sp95E10),
                    "SP98" => Some(Self::Sp98),
                    "SP99" => Some(Self::Sp99),
                    "SP100" => Some(Self::Sp100),
                    "LPG" => Some(Self::Lpg),
                    "E80" => Some(Self::E80),
                    "E85" => Some(Self::E85),
                    "E100" => Some(Self::E100),
                    "METHANE" => Some(Self::Methane),
                    "BIO_DIESEL" => Some(Self::BioDiesel),
                    "TRUCK_DIESEL" => Some(Self::TruckDiesel),
                    _ => None,
                }
            }
        }
    }
}
/// Circle with a LatLng as center and radius.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct Circle {
    /// Required. Center latitude and longitude.
    ///
    /// The range of latitude must be within \[-90.0, 90.0\]. The range of the
    /// longitude must be within \[-180.0, 180.0\].
    #[prost(message, optional, tag = "1")]
    pub center: ::core::option::Option<super::super::super::r#type::LatLng>,
    /// Required. Radius measured in meters. The radius must be within \[0.0,
    /// 50000.0\].
    #[prost(double, tag = "2")]
    pub radius: f64,
}
/// The price range associated with a Place. `end_price` could be unset, which
/// indicates a range without upper bound (e.g. "More than $100").
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PriceRange {
    /// The low end of the price range (inclusive). Price should be at or above
    /// this amount.
    #[prost(message, optional, tag = "1")]
    pub start_price: ::core::option::Option<super::super::super::r#type::Money>,
    /// The high end of the price range (exclusive). Price should be lower than
    /// this amount.
    #[prost(message, optional, tag = "2")]
    pub end_price: ::core::option::Option<super::super::super::r#type::Money>,
}
/// All the information representing a Place.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Place {
    /// This Place's resource name, in `places/{place_id}` format.  Can be used to
    /// look up the Place.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The unique identifier of a place.
    #[prost(string, tag = "2")]
    pub id: ::prost::alloc::string::String,
    /// The localized name of the place, suitable as a short human-readable
    /// description. For example, "Google Sydney", "Starbucks", "Pyrmont", etc.
    #[prost(message, optional, tag = "31")]
    pub display_name: ::core::option::Option<super::super::super::r#type::LocalizedText>,
    /// A set of type tags for this result. For example, "political" and
    /// "locality". 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>
    #[prost(string, repeated, tag = "5")]
    pub types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The primary type of the given result. This type must be one of the Places
    /// API supported types. For example, "restaurant", "cafe", "airport", etc.  A
    /// place can only have a single primary type.  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.>
    /// The primary type may be missing if the place's primary type is not a
    /// supported type. When a primary type is present, it is always one of the
    /// types in the `types` field.
    #[prost(string, tag = "50")]
    pub primary_type: ::prost::alloc::string::String,
    /// The display name of the primary type, localized to the request language if
    /// applicable. 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.>
    /// The primary type may be missing if the place's primary type is not a
    /// supported type.
    #[prost(message, optional, tag = "32")]
    pub primary_type_display_name: ::core::option::Option<
        super::super::super::r#type::LocalizedText,
    >,
    /// A human-readable phone number for the place, in national format.
    #[prost(string, tag = "7")]
    pub national_phone_number: ::prost::alloc::string::String,
    /// A human-readable phone number for the place, in international format.
    #[prost(string, tag = "8")]
    pub international_phone_number: ::prost::alloc::string::String,
    /// A full, human-readable address for this place.
    #[prost(string, tag = "9")]
    pub formatted_address: ::prost::alloc::string::String,
    /// A short, human-readable address for this place.
    #[prost(string, tag = "51")]
    pub short_formatted_address: ::prost::alloc::string::String,
    /// The address in postal address format.
    #[prost(message, optional, tag = "90")]
    pub postal_address: ::core::option::Option<
        super::super::super::r#type::PostalAddress,
    >,
    /// Repeated components for each locality level.
    /// Note the following facts about the address_components\[\] array:
    ///
    /// * The array of address components may contain more components than the
    ///   formatted_address.
    /// * The array does not necessarily include all the political entities that
    ///   contain an address, apart from those included in the formatted_address. To
    ///   retrieve all the political entities that contain a specific address, you
    ///   should use reverse geocoding, passing the latitude/longitude of the address
    ///   as a parameter to the request.
    /// * The format of the response is not guaranteed to remain the same between
    ///   requests. In particular, the number of address_components varies based on
    ///   the address requested and can change over time for the same address. A
    ///   component can change position in the array. The type of the component can
    ///   change. A particular component may be missing in a later response.
    #[prost(message, repeated, tag = "10")]
    pub address_components: ::prost::alloc::vec::Vec<place::AddressComponent>,
    /// Plus code of the place location lat/long.
    #[prost(message, optional, tag = "11")]
    pub plus_code: ::core::option::Option<place::PlusCode>,
    /// The position of this place.
    #[prost(message, optional, tag = "12")]
    pub location: ::core::option::Option<super::super::super::r#type::LatLng>,
    /// A viewport suitable for displaying the place on an average-sized map. This
    /// viewport should not be used as the physical boundary or the service area of
    /// the business.
    #[prost(message, optional, tag = "13")]
    pub viewport: ::core::option::Option<super::super::super::geo::r#type::Viewport>,
    /// A rating between 1.0 and 5.0, based on user reviews of this place.
    #[prost(double, tag = "14")]
    pub rating: f64,
    /// A URL providing more information about this place.
    #[prost(string, tag = "15")]
    pub google_maps_uri: ::prost::alloc::string::String,
    /// The authoritative website for this place, e.g. a business' homepage.
    /// Note that for places that are part of a chain (e.g. an IKEA store), this
    /// will usually be the website for the individual store, not the overall
    /// chain.
    #[prost(string, tag = "16")]
    pub website_uri: ::prost::alloc::string::String,
    /// List of reviews about this place, sorted by relevance. A maximum of 5
    /// reviews can be returned.
    #[prost(message, repeated, tag = "53")]
    pub reviews: ::prost::alloc::vec::Vec<Review>,
    /// The regular hours of operation. Note that if a place is always open (24
    /// hours), the `close` field will not be set. Clients can rely on always open
    /// (24 hours) being represented as an
    /// [`open`](<https://developers.google.com/maps/documentation/places/web-service/reference/rest/v1/places#Period>)
    /// period containing
    /// [`day`](<https://developers.google.com/maps/documentation/places/web-service/reference/rest/v1/places#Point>)
    /// with value `0`,
    /// [`hour`](<https://developers.google.com/maps/documentation/places/web-service/reference/rest/v1/places#Point>)
    /// with value `0`, and
    /// [`minute`](<https://developers.google.com/maps/documentation/places/web-service/reference/rest/v1/places#Point>)
    /// with value `0`.
    #[prost(message, optional, tag = "21")]
    pub regular_opening_hours: ::core::option::Option<place::OpeningHours>,
    /// Number of minutes this place's timezone is currently offset from UTC.
    /// This is expressed in minutes to support timezones that are offset by
    /// fractions of an hour, e.g. X hours and 15 minutes.
    #[prost(int32, optional, tag = "22")]
    pub utc_offset_minutes: ::core::option::Option<i32>,
    /// IANA Time Zone Database time zone. For example "America/New_York".
    #[prost(message, optional, tag = "88")]
    pub time_zone: ::core::option::Option<super::super::super::r#type::TimeZone>,
    /// Information (including references) about photos of this place. A maximum of
    /// 10 photos can be returned.
    #[prost(message, repeated, tag = "54")]
    pub photos: ::prost::alloc::vec::Vec<Photo>,
    /// The place's address in adr microformat: <http://microformats.org/wiki/adr.>
    #[prost(string, tag = "24")]
    pub adr_format_address: ::prost::alloc::string::String,
    /// The business status for the place.
    #[prost(enumeration = "place::BusinessStatus", tag = "25")]
    pub business_status: i32,
    /// Price level of the place.
    #[prost(enumeration = "PriceLevel", tag = "26")]
    pub price_level: i32,
    /// A set of data provider that must be shown with this result.
    #[prost(message, repeated, tag = "27")]
    pub attributions: ::prost::alloc::vec::Vec<place::Attribution>,
    /// The total number of reviews (with or without text) for this place.
    #[prost(int32, optional, tag = "28")]
    pub user_rating_count: ::core::option::Option<i32>,
    /// A truncated URL to an icon mask. User can access different icon type by
    /// appending type suffix to the end (eg, ".svg" or ".png").
    #[prost(string, tag = "29")]
    pub icon_mask_base_uri: ::prost::alloc::string::String,
    /// Background color for icon_mask in hex format, e.g. #909CE1.
    #[prost(string, tag = "30")]
    pub icon_background_color: ::prost::alloc::string::String,
    /// Specifies if the business supports takeout.
    #[prost(bool, optional, tag = "33")]
    pub takeout: ::core::option::Option<bool>,
    /// Specifies if the business supports delivery.
    #[prost(bool, optional, tag = "34")]
    pub delivery: ::core::option::Option<bool>,
    /// Specifies if the business supports indoor or outdoor seating options.
    #[prost(bool, optional, tag = "35")]
    pub dine_in: ::core::option::Option<bool>,
    /// Specifies if the business supports curbside pickup.
    #[prost(bool, optional, tag = "36")]
    pub curbside_pickup: ::core::option::Option<bool>,
    /// Specifies if the place supports reservations.
    #[prost(bool, optional, tag = "38")]
    pub reservable: ::core::option::Option<bool>,
    /// Specifies if the place serves breakfast.
    #[prost(bool, optional, tag = "39")]
    pub serves_breakfast: ::core::option::Option<bool>,
    /// Specifies if the place serves lunch.
    #[prost(bool, optional, tag = "40")]
    pub serves_lunch: ::core::option::Option<bool>,
    /// Specifies if the place serves dinner.
    #[prost(bool, optional, tag = "41")]
    pub serves_dinner: ::core::option::Option<bool>,
    /// Specifies if the place serves beer.
    #[prost(bool, optional, tag = "42")]
    pub serves_beer: ::core::option::Option<bool>,
    /// Specifies if the place serves wine.
    #[prost(bool, optional, tag = "43")]
    pub serves_wine: ::core::option::Option<bool>,
    /// Specifies if the place serves brunch.
    #[prost(bool, optional, tag = "44")]
    pub serves_brunch: ::core::option::Option<bool>,
    /// Specifies if the place serves vegetarian food.
    #[prost(bool, optional, tag = "45")]
    pub serves_vegetarian_food: ::core::option::Option<bool>,
    /// The hours of operation for the next seven days (including today). The time
    /// period starts at midnight on the date of the request and ends at 11:59 pm
    /// six days later. This field includes the special_days subfield of all hours,
    /// set for dates that have exceptional hours.
    #[prost(message, optional, tag = "46")]
    pub current_opening_hours: ::core::option::Option<place::OpeningHours>,
    /// Contains an array of entries for the next seven days including information
    /// about secondary hours of a business. Secondary hours are different from a
    /// business's main hours. For example, a restaurant can specify drive through
    /// hours or delivery hours as its secondary hours. This field populates the
    /// type subfield, which draws from a predefined list of opening hours types
    /// (such as DRIVE_THROUGH, PICKUP, or TAKEOUT) based on the types of the
    /// place. This field includes the special_days subfield of all hours, set for
    /// dates that have exceptional hours.
    #[prost(message, repeated, tag = "47")]
    pub current_secondary_opening_hours: ::prost::alloc::vec::Vec<place::OpeningHours>,
    /// Contains an array of entries for information about regular secondary hours
    /// of a business. Secondary hours are different from a business's main hours.
    /// For example, a restaurant can specify drive through hours or delivery hours
    /// as its secondary hours. This field populates the type subfield, which draws
    /// from a predefined list of opening hours types (such as DRIVE_THROUGH,
    /// PICKUP, or TAKEOUT) based on the types of the place.
    #[prost(message, repeated, tag = "49")]
    pub regular_secondary_opening_hours: ::prost::alloc::vec::Vec<place::OpeningHours>,
    /// Contains a summary of the place. A summary is comprised of a textual
    /// overview, and also includes the language code for these if applicable.
    /// Summary text must be presented as-is and can not be modified or altered.
    #[prost(message, optional, tag = "52")]
    pub editorial_summary: ::core::option::Option<
        super::super::super::r#type::LocalizedText,
    >,
    /// Place provides outdoor seating.
    #[prost(bool, optional, tag = "55")]
    pub outdoor_seating: ::core::option::Option<bool>,
    /// Place provides live music.
    #[prost(bool, optional, tag = "56")]
    pub live_music: ::core::option::Option<bool>,
    /// Place has a children's menu.
    #[prost(bool, optional, tag = "57")]
    pub menu_for_children: ::core::option::Option<bool>,
    /// Place serves cocktails.
    #[prost(bool, optional, tag = "58")]
    pub serves_cocktails: ::core::option::Option<bool>,
    /// Place serves dessert.
    #[prost(bool, optional, tag = "59")]
    pub serves_dessert: ::core::option::Option<bool>,
    /// Place serves coffee.
    #[prost(bool, optional, tag = "60")]
    pub serves_coffee: ::core::option::Option<bool>,
    /// Place is good for children.
    #[prost(bool, optional, tag = "62")]
    pub good_for_children: ::core::option::Option<bool>,
    /// Place allows dogs.
    #[prost(bool, optional, tag = "63")]
    pub allows_dogs: ::core::option::Option<bool>,
    /// Place has restroom.
    #[prost(bool, optional, tag = "64")]
    pub restroom: ::core::option::Option<bool>,
    /// Place accommodates groups.
    #[prost(bool, optional, tag = "65")]
    pub good_for_groups: ::core::option::Option<bool>,
    /// Place is suitable for watching sports.
    #[prost(bool, optional, tag = "66")]
    pub good_for_watching_sports: ::core::option::Option<bool>,
    /// Payment options the place accepts. If a payment option data is not
    /// available, the payment option field will be unset.
    #[prost(message, optional, tag = "67")]
    pub payment_options: ::core::option::Option<place::PaymentOptions>,
    /// Options of parking provided by the place.
    #[prost(message, optional, tag = "70")]
    pub parking_options: ::core::option::Option<place::ParkingOptions>,
    /// A list of sub-destinations related to the place.
    #[prost(message, repeated, tag = "71")]
    pub sub_destinations: ::prost::alloc::vec::Vec<place::SubDestination>,
    /// Information about the accessibility options a place offers.
    #[prost(message, optional, tag = "72")]
    pub accessibility_options: ::core::option::Option<place::AccessibilityOptions>,
    /// The most recent information about fuel options in a gas station. This
    /// information is updated regularly.
    #[prost(message, optional, tag = "78")]
    pub fuel_options: ::core::option::Option<FuelOptions>,
    /// Information of ev charging options.
    #[prost(message, optional, tag = "79")]
    pub ev_charge_options: ::core::option::Option<EvChargeOptions>,
    /// AI-generated summary of the place.
    #[prost(message, optional, tag = "80")]
    pub generative_summary: ::core::option::Option<place::GenerativeSummary>,
    /// List of places in which the current place is located.
    #[prost(message, repeated, tag = "82")]
    pub containing_places: ::prost::alloc::vec::Vec<place::ContainingPlace>,
    /// Indicates whether the place is a pure service area business. Pure service
    /// area business is a business that visits or delivers to customers directly
    /// but does not serve customers at their business address. For example,
    /// businesses like cleaning services or plumbers. Those businesses may not
    /// have a physical address or location on Google Maps.
    #[prost(bool, optional, tag = "83")]
    pub pure_service_area_business: ::core::option::Option<bool>,
    /// The address descriptor of the place. Address descriptors include additional
    /// information that help describe a location using landmarks and areas. See
    /// address descriptor regional coverage in
    /// <https://developers.google.com/maps/documentation/geocoding/address-descriptors/coverage.>
    #[prost(message, optional, tag = "84")]
    pub address_descriptor: ::core::option::Option<AddressDescriptor>,
    /// The price range associated with a Place.
    #[prost(message, optional, tag = "86")]
    pub price_range: ::core::option::Option<PriceRange>,
    /// AI-generated summary of the place using user reviews.
    #[prost(message, optional, tag = "87")]
    pub review_summary: ::core::option::Option<place::ReviewSummary>,
    /// The summary of amenities near the EV charging station.
    #[prost(message, optional, tag = "89")]
    pub ev_charge_amenity_summary: ::core::option::Option<place::EvChargeAmenitySummary>,
    /// A summary of points of interest near the place.
    #[prost(message, optional, tag = "91")]
    pub neighborhood_summary: ::core::option::Option<place::NeighborhoodSummary>,
}
/// Nested message and enum types in `Place`.
pub mod place {
    /// The structured components that form the formatted address, if this
    /// information is available.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    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".
        #[prost(string, tag = "1")]
        pub long_text: ::prost::alloc::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".
        #[prost(string, tag = "2")]
        pub short_text: ::prost::alloc::string::String,
        /// An array indicating the type(s) of the address component.
        #[prost(string, repeated, tag = "3")]
        pub types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// The language used to format this components, in CLDR notation.
        #[prost(string, tag = "4")]
        pub language_code: ::prost::alloc::string::String,
    }
    /// 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, PartialEq, Eq, Hash, ::prost::Message)]
    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).
        #[prost(string, tag = "1")]
        pub global_code: ::prost::alloc::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.
        #[prost(string, tag = "2")]
        pub compound_code: ::prost::alloc::string::String,
    }
    /// Information about business hour of the place.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct OpeningHours {
        /// Whether the opening hours period is currently active. For regular opening
        /// hours and current opening hours, this field means whether the place is
        /// open. For secondary opening hours and current secondary opening hours,
        /// this field means whether the secondary hours of this place is active.
        #[prost(bool, optional, tag = "1")]
        pub open_now: ::core::option::Option<bool>,
        /// The periods that this place is open during the week. The periods are in
        /// chronological order, in the place-local timezone. An empty (but not
        /// absent) value indicates a place that is never open, e.g.
        /// because it is closed temporarily for renovations.
        ///
        /// The starting day of `periods` is NOT fixed and should not be assumed to
        /// be Sunday. The API determines the start day based on a variety of
        /// factors. For example, for a 24/7 business, the first period may begin on
        /// the day of the request. For other businesses, it might be the first day
        /// of the week that they are open.
        ///
        /// NOTE: The ordering of the `periods` array is independent of the ordering
        /// of the `weekday_descriptions` array. Do not assume they will begin on the
        /// same day.
        #[prost(message, repeated, tag = "2")]
        pub periods: ::prost::alloc::vec::Vec<opening_hours::Period>,
        /// Localized strings describing the opening hours of this place, one string
        /// for each day of the week.
        ///
        /// NOTE: The order of the days and the start of the week is determined by
        /// the locale (language and region). The ordering of the `periods` array is
        /// independent of the ordering of the `weekday_descriptions` array. Do not
        /// assume they will begin on the same day.
        ///
        /// Will be empty if the hours are unknown or could not be converted to
        /// localized text. Example: "Sun: 18:00–06:00"
        #[prost(string, repeated, tag = "3")]
        pub weekday_descriptions: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
        /// A type string used to identify the type of secondary hours.
        #[prost(enumeration = "opening_hours::SecondaryHoursType", tag = "4")]
        pub secondary_hours_type: i32,
        /// Structured information for special days that fall within the period that
        /// the returned opening hours cover. Special days are days that could impact
        /// the business hours of a place, e.g. Christmas day. Set for
        /// current_opening_hours and current_secondary_opening_hours if there are
        /// exceptional hours.
        #[prost(message, repeated, tag = "5")]
        pub special_days: ::prost::alloc::vec::Vec<opening_hours::SpecialDay>,
        /// The next time the current opening hours period starts up to 7 days in the
        /// future. This field is only populated if the opening hours period is not
        /// active at the time of serving the request.
        #[prost(message, optional, tag = "6")]
        pub next_open_time: ::core::option::Option<::prost_types::Timestamp>,
        /// The next time the current opening hours period ends up to 7 days in the
        /// future. This field is only populated if the opening hours period is
        /// active at the time of serving the request.
        #[prost(message, optional, tag = "7")]
        pub next_close_time: ::core::option::Option<::prost_types::Timestamp>,
    }
    /// Nested message and enum types in `OpeningHours`.
    pub mod opening_hours {
        /// A period the place remains in open_now status.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct Period {
            /// The time that the place starts to be open.
            #[prost(message, optional, tag = "1")]
            pub open: ::core::option::Option<period::Point>,
            /// The time that the place starts to be closed.
            #[prost(message, optional, tag = "2")]
            pub close: ::core::option::Option<period::Point>,
        }
        /// Nested message and enum types in `Period`.
        pub mod period {
            /// Status changing points.
            #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
            pub struct Point {
                /// A day of the week, as an integer in the range 0-6.  0 is Sunday, 1 is
                /// Monday, etc.
                #[prost(int32, optional, tag = "1")]
                pub day: ::core::option::Option<i32>,
                /// The hour in 24 hour format. Ranges from 0 to 23.
                #[prost(int32, optional, tag = "2")]
                pub hour: ::core::option::Option<i32>,
                /// The minute. Ranges from 0 to 59.
                #[prost(int32, optional, tag = "3")]
                pub minute: ::core::option::Option<i32>,
                /// Date in the local timezone for the place.
                #[prost(message, optional, tag = "6")]
                pub date: ::core::option::Option<
                    super::super::super::super::super::super::r#type::Date,
                >,
                /// Whether or not this endpoint was truncated. Truncation occurs when
                /// the real hours are outside the times we are willing to return hours
                /// between, so we truncate the hours back to these boundaries. This
                /// ensures that at most 24 * 7 hours from midnight of the day of the
                /// request are returned.
                #[prost(bool, tag = "5")]
                pub truncated: bool,
            }
        }
        /// Structured information for special days that fall within the period that
        /// the returned opening hours cover. Special days are days that could impact
        /// the business hours of a place, e.g. Christmas day.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct SpecialDay {
            /// The date of this special day.
            #[prost(message, optional, tag = "1")]
            pub date: ::core::option::Option<
                super::super::super::super::super::r#type::Date,
            >,
        }
        /// A type used to identify the type of secondary hours.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum SecondaryHoursType {
            /// Default value when secondary hour type is not specified.
            Unspecified = 0,
            /// The drive-through hour for banks, restaurants, or pharmacies.
            DriveThrough = 1,
            /// The happy hour.
            HappyHour = 2,
            /// The delivery hour.
            Delivery = 3,
            /// The takeout hour.
            Takeout = 4,
            /// The kitchen hour.
            Kitchen = 5,
            /// The breakfast hour.
            Breakfast = 6,
            /// The lunch hour.
            Lunch = 7,
            /// The dinner hour.
            Dinner = 8,
            /// The brunch hour.
            Brunch = 9,
            /// The pickup hour.
            Pickup = 10,
            /// The access hours for storage places.
            Access = 11,
            /// The special hours for seniors.
            SeniorHours = 12,
            /// The online service hours.
            OnlineServiceHours = 13,
        }
        impl SecondaryHoursType {
            /// String value of the enum field names used in the ProtoBuf definition.
            ///
            /// The values are not transformed in any way and thus are considered stable
            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
            pub fn as_str_name(&self) -> &'static str {
                match self {
                    Self::Unspecified => "SECONDARY_HOURS_TYPE_UNSPECIFIED",
                    Self::DriveThrough => "DRIVE_THROUGH",
                    Self::HappyHour => "HAPPY_HOUR",
                    Self::Delivery => "DELIVERY",
                    Self::Takeout => "TAKEOUT",
                    Self::Kitchen => "KITCHEN",
                    Self::Breakfast => "BREAKFAST",
                    Self::Lunch => "LUNCH",
                    Self::Dinner => "DINNER",
                    Self::Brunch => "BRUNCH",
                    Self::Pickup => "PICKUP",
                    Self::Access => "ACCESS",
                    Self::SeniorHours => "SENIOR_HOURS",
                    Self::OnlineServiceHours => "ONLINE_SERVICE_HOURS",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "SECONDARY_HOURS_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "DRIVE_THROUGH" => Some(Self::DriveThrough),
                    "HAPPY_HOUR" => Some(Self::HappyHour),
                    "DELIVERY" => Some(Self::Delivery),
                    "TAKEOUT" => Some(Self::Takeout),
                    "KITCHEN" => Some(Self::Kitchen),
                    "BREAKFAST" => Some(Self::Breakfast),
                    "LUNCH" => Some(Self::Lunch),
                    "DINNER" => Some(Self::Dinner),
                    "BRUNCH" => Some(Self::Brunch),
                    "PICKUP" => Some(Self::Pickup),
                    "ACCESS" => Some(Self::Access),
                    "SENIOR_HOURS" => Some(Self::SeniorHours),
                    "ONLINE_SERVICE_HOURS" => Some(Self::OnlineServiceHours),
                    _ => None,
                }
            }
        }
    }
    /// Information about data providers of this place.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Attribution {
        /// Name of the Place's data provider.
        #[prost(string, tag = "1")]
        pub provider: ::prost::alloc::string::String,
        /// URI to the Place's data provider.
        #[prost(string, tag = "2")]
        pub provider_uri: ::prost::alloc::string::String,
    }
    /// Payment options the place accepts.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct PaymentOptions {
        /// Place accepts credit cards as payment.
        #[prost(bool, optional, tag = "1")]
        pub accepts_credit_cards: ::core::option::Option<bool>,
        /// Place accepts debit cards as payment.
        #[prost(bool, optional, tag = "2")]
        pub accepts_debit_cards: ::core::option::Option<bool>,
        /// Place accepts cash only as payment. Places with this attribute may still
        /// accept other payment methods.
        #[prost(bool, optional, tag = "3")]
        pub accepts_cash_only: ::core::option::Option<bool>,
        /// Place accepts NFC payments.
        #[prost(bool, optional, tag = "4")]
        pub accepts_nfc: ::core::option::Option<bool>,
    }
    /// Information about parking options for the place. A parking lot could
    /// support more than one option at the same time.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ParkingOptions {
        /// Place offers free parking lots.
        #[prost(bool, optional, tag = "1")]
        pub free_parking_lot: ::core::option::Option<bool>,
        /// Place offers paid parking lots.
        #[prost(bool, optional, tag = "2")]
        pub paid_parking_lot: ::core::option::Option<bool>,
        /// Place offers free street parking.
        #[prost(bool, optional, tag = "3")]
        pub free_street_parking: ::core::option::Option<bool>,
        /// Place offers paid street parking.
        #[prost(bool, optional, tag = "4")]
        pub paid_street_parking: ::core::option::Option<bool>,
        /// Place offers valet parking.
        #[prost(bool, optional, tag = "5")]
        pub valet_parking: ::core::option::Option<bool>,
        /// Place offers free garage parking.
        #[prost(bool, optional, tag = "6")]
        pub free_garage_parking: ::core::option::Option<bool>,
        /// Place offers paid garage parking.
        #[prost(bool, optional, tag = "7")]
        pub paid_garage_parking: ::core::option::Option<bool>,
    }
    /// Sub-destinations are specific places associated with a main place. These
    /// provide more specific destinations for users who are searching within a
    /// large or complex place, like an airport, national park, university, or
    /// stadium. For example, sub-destinations at an airport might include
    /// associated terminals and parking lots. Sub-destinations return the place ID
    /// and place resource name, which can be used in subsequent Place Details
    /// (New) requests to fetch richer details, including the sub-destination's
    /// display name and location.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct SubDestination {
        /// The resource name of the sub-destination.
        #[prost(string, tag = "1")]
        pub name: ::prost::alloc::string::String,
        /// The place id of the sub-destination.
        #[prost(string, tag = "2")]
        pub id: ::prost::alloc::string::String,
    }
    /// Information about the accessibility options a place offers.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AccessibilityOptions {
        /// Place offers wheelchair accessible parking.
        #[prost(bool, optional, tag = "1")]
        pub wheelchair_accessible_parking: ::core::option::Option<bool>,
        /// Places has wheelchair accessible entrance.
        #[prost(bool, optional, tag = "2")]
        pub wheelchair_accessible_entrance: ::core::option::Option<bool>,
        /// Place has wheelchair accessible restroom.
        #[prost(bool, optional, tag = "3")]
        pub wheelchair_accessible_restroom: ::core::option::Option<bool>,
        /// Place has wheelchair accessible seating.
        #[prost(bool, optional, tag = "4")]
        pub wheelchair_accessible_seating: ::core::option::Option<bool>,
    }
    /// AI-generated summary of the place.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct GenerativeSummary {
        /// The overview of the place.
        #[prost(message, optional, tag = "1")]
        pub overview: ::core::option::Option<
            super::super::super::super::r#type::LocalizedText,
        >,
        /// A link where users can flag a problem with the overview summary.
        #[prost(string, tag = "4")]
        pub overview_flag_content_uri: ::prost::alloc::string::String,
        /// The AI disclosure message "Summarized with Gemini"
        /// (and its localized variants). This will be in the language specified in
        /// the request if available.
        #[prost(message, optional, tag = "6")]
        pub disclosure_text: ::core::option::Option<
            super::super::super::super::r#type::LocalizedText,
        >,
    }
    /// Info about the place in which this place is located.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ContainingPlace {
        /// The resource name of the place in which this place is located.
        #[prost(string, tag = "1")]
        pub name: ::prost::alloc::string::String,
        /// The place id of the place in which this place is located.
        #[prost(string, tag = "2")]
        pub id: ::prost::alloc::string::String,
    }
    /// AI-generated summary of the place using user reviews.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ReviewSummary {
        /// The summary of user reviews.
        #[prost(message, optional, tag = "1")]
        pub text: ::core::option::Option<
            super::super::super::super::r#type::LocalizedText,
        >,
        /// A link where users can flag a problem with the summary.
        #[prost(string, tag = "2")]
        pub flag_content_uri: ::prost::alloc::string::String,
        /// The AI disclosure message "Summarized with Gemini"
        /// (and its localized variants). This will be in the language specified in
        /// the request if available.
        #[prost(message, optional, tag = "3")]
        pub disclosure_text: ::core::option::Option<
            super::super::super::super::r#type::LocalizedText,
        >,
    }
    /// The summary of amenities near the EV charging station. This only applies to
    /// places with type `electric_vehicle_charging_station`. The `overview` field
    /// is guaranteed to be provided while the other fields are optional.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct EvChargeAmenitySummary {
        /// An overview of the available amenities. This is guaranteed to be
        /// provided.
        #[prost(message, optional, tag = "1")]
        pub overview: ::core::option::Option<super::ContentBlock>,
        /// A summary of the nearby coffee options.
        #[prost(message, optional, tag = "2")]
        pub coffee: ::core::option::Option<super::ContentBlock>,
        /// A summary of the nearby restaurants.
        #[prost(message, optional, tag = "3")]
        pub restaurant: ::core::option::Option<super::ContentBlock>,
        /// A summary of the nearby gas stations.
        #[prost(message, optional, tag = "4")]
        pub store: ::core::option::Option<super::ContentBlock>,
        /// A link where users can flag a problem with the summary.
        #[prost(string, tag = "5")]
        pub flag_content_uri: ::prost::alloc::string::String,
        /// The AI disclosure message "Summarized with Gemini"
        /// (and its localized variants). This will be in the language specified in
        /// the request if available.
        #[prost(message, optional, tag = "6")]
        pub disclosure_text: ::core::option::Option<
            super::super::super::super::r#type::LocalizedText,
        >,
    }
    /// A summary of points of interest near the place.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct NeighborhoodSummary {
        /// An overview summary of the neighborhood.
        #[prost(message, optional, tag = "1")]
        pub overview: ::core::option::Option<super::ContentBlock>,
        /// A detailed description of the neighborhood.
        #[prost(message, optional, tag = "2")]
        pub description: ::core::option::Option<super::ContentBlock>,
        /// A link where users can flag a problem with the summary.
        #[prost(string, tag = "3")]
        pub flag_content_uri: ::prost::alloc::string::String,
        /// The AI disclosure message "Summarized with Gemini"
        /// (and its localized variants). This will be in the language specified in
        /// the request if available.
        #[prost(message, optional, tag = "4")]
        pub disclosure_text: ::core::option::Option<
            super::super::super::super::r#type::LocalizedText,
        >,
    }
    /// Business status for the place.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum BusinessStatus {
        /// Default value. This value is unused.
        Unspecified = 0,
        /// The establishment is operational, not necessarily open now.
        Operational = 1,
        /// The establishment is temporarily closed.
        ClosedTemporarily = 2,
        /// The establishment is permanently closed.
        ClosedPermanently = 3,
    }
    impl BusinessStatus {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "BUSINESS_STATUS_UNSPECIFIED",
                Self::Operational => "OPERATIONAL",
                Self::ClosedTemporarily => "CLOSED_TEMPORARILY",
                Self::ClosedPermanently => "CLOSED_PERMANENTLY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "BUSINESS_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "OPERATIONAL" => Some(Self::Operational),
                "CLOSED_TEMPORARILY" => Some(Self::ClosedTemporarily),
                "CLOSED_PERMANENTLY" => Some(Self::ClosedPermanently),
                _ => None,
            }
        }
    }
}
/// Price level of the place.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum PriceLevel {
    /// Place price level is unspecified or unknown.
    Unspecified = 0,
    /// Place provides free services.
    Free = 1,
    /// Place provides inexpensive services.
    Inexpensive = 2,
    /// Place provides moderately priced services.
    Moderate = 3,
    /// Place provides expensive services.
    Expensive = 4,
    /// Place provides very expensive services.
    VeryExpensive = 5,
}
impl PriceLevel {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "PRICE_LEVEL_UNSPECIFIED",
            Self::Free => "PRICE_LEVEL_FREE",
            Self::Inexpensive => "PRICE_LEVEL_INEXPENSIVE",
            Self::Moderate => "PRICE_LEVEL_MODERATE",
            Self::Expensive => "PRICE_LEVEL_EXPENSIVE",
            Self::VeryExpensive => "PRICE_LEVEL_VERY_EXPENSIVE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "PRICE_LEVEL_UNSPECIFIED" => Some(Self::Unspecified),
            "PRICE_LEVEL_FREE" => Some(Self::Free),
            "PRICE_LEVEL_INEXPENSIVE" => Some(Self::Inexpensive),
            "PRICE_LEVEL_MODERATE" => Some(Self::Moderate),
            "PRICE_LEVEL_EXPENSIVE" => Some(Self::Expensive),
            "PRICE_LEVEL_VERY_EXPENSIVE" => Some(Self::VeryExpensive),
            _ => None,
        }
    }
}
/// A route polyline.  Only supports an [encoded
/// polyline](<https://developers.google.com/maps/documentation/utilities/polylinealgorithm>),
/// which can be passed as a string and includes compression with minimal
/// lossiness. This is the Routes API default output.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Polyline {
    /// Encapsulates the type of polyline. Routes API output defaults to
    /// `encoded_polyline`.
    #[prost(oneof = "polyline::PolylineType", tags = "1")]
    pub polyline_type: ::core::option::Option<polyline::PolylineType>,
}
/// Nested message and enum types in `Polyline`.
pub mod polyline {
    /// Encapsulates the type of polyline. Routes API output defaults to
    /// `encoded_polyline`.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum PolylineType {
        /// An [encoded
        /// polyline](<https://developers.google.com/maps/documentation/utilities/polylinealgorithm>),
        /// as returned by the [Routes API by
        /// default](<https://developers.google.com/maps/documentation/routes/reference/rest/v2/TopLevel/computeRoutes#polylineencoding>).
        /// See the
        /// [encoder](<https://developers.google.com/maps/documentation/utilities/polylineutility>)
        /// and
        /// [decoder](<https://developers.google.com/maps/documentation/routes/polylinedecoder>)
        /// tools.
        #[prost(string, tag = "1")]
        EncodedPolyline(::prost::alloc::string::String),
    }
}
/// Encapsulates a set of optional conditions to satisfy when calculating the
/// routes.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RouteModifiers {
    /// Optional. When set to true, avoids toll roads where reasonable, giving
    /// preference to routes not containing toll roads. Applies only to the `DRIVE`
    /// and `TWO_WHEELER` \[`TravelMode`\]\[google.maps.places.v1.TravelMode\].
    #[prost(bool, tag = "1")]
    pub avoid_tolls: bool,
    /// Optional. When set to true, avoids highways where reasonable, giving
    /// preference to routes not containing highways. Applies only to the `DRIVE`
    /// and `TWO_WHEELER` \[`TravelMode`\]\[google.maps.places.v1.TravelMode\].
    #[prost(bool, tag = "2")]
    pub avoid_highways: bool,
    /// Optional. When set to true, avoids ferries where reasonable, giving
    /// preference to routes not containing ferries. Applies only to the `DRIVE`
    /// and `TWO_WHEELER` \[`TravelMode`\]\[google.maps.places.v1.TravelMode\].
    #[prost(bool, tag = "3")]
    pub avoid_ferries: bool,
    /// Optional. When set to true, avoids navigating indoors where reasonable,
    /// giving preference to routes not containing indoor navigation. Applies only
    /// to the `WALK` \[`TravelMode`\]\[google.maps.places.v1.TravelMode\].
    #[prost(bool, tag = "4")]
    pub avoid_indoor: bool,
}
/// A set of values that specify factors to take into consideration when
/// calculating the route.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum RoutingPreference {
    /// No routing preference specified. Default to `TRAFFIC_UNAWARE`.
    Unspecified = 0,
    /// Computes routes without taking live traffic conditions into consideration.
    /// Suitable when traffic conditions don't matter or are not applicable.
    /// Using this value produces the lowest latency.
    /// Note: For \[`TravelMode`\]\[google.maps.places.v1.TravelMode\]
    /// `DRIVE` and `TWO_WHEELER`, the route and duration chosen are based on road
    /// network and average time-independent traffic conditions, not current road
    /// conditions. Consequently, routes may include roads that are temporarily
    /// closed. Results for a given
    /// request may vary over time due to changes in the road network, updated
    /// average traffic conditions, and the distributed nature of the service.
    /// Results may also vary between nearly-equivalent routes at any time or
    /// frequency.
    TrafficUnaware = 1,
    /// Calculates routes taking live traffic conditions into consideration.
    /// In contrast to `TRAFFIC_AWARE_OPTIMAL`, some optimizations are applied to
    /// significantly reduce latency.
    TrafficAware = 2,
    /// Calculates the routes taking live traffic conditions into consideration,
    /// without applying most performance optimizations. Using this value produces
    /// the highest latency.
    TrafficAwareOptimal = 3,
}
impl RoutingPreference {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "ROUTING_PREFERENCE_UNSPECIFIED",
            Self::TrafficUnaware => "TRAFFIC_UNAWARE",
            Self::TrafficAware => "TRAFFIC_AWARE",
            Self::TrafficAwareOptimal => "TRAFFIC_AWARE_OPTIMAL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ROUTING_PREFERENCE_UNSPECIFIED" => Some(Self::Unspecified),
            "TRAFFIC_UNAWARE" => Some(Self::TrafficUnaware),
            "TRAFFIC_AWARE" => Some(Self::TrafficAware),
            "TRAFFIC_AWARE_OPTIMAL" => Some(Self::TrafficAwareOptimal),
            _ => None,
        }
    }
}
/// The duration and distance from the routing origin to a place in the
/// response, and a second leg from that place to the destination, if requested.
/// **Note:** Adding `routingSummaries` in the field mask without also including
/// either the `routingParameters.origin` parameter or the
/// `searchAlongRouteParameters.polyline.encodedPolyline` parameter in the
/// request causes an error.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RoutingSummary {
    /// The legs of the trip.
    ///
    /// When you calculate travel duration and distance from a set origin, `legs`
    /// contains a single leg containing the duration and distance from the origin
    /// to the destination.  When you do a search along route, `legs` contains two
    /// legs: one from the origin to place, and one from the place to the
    /// destination.
    #[prost(message, repeated, tag = "1")]
    pub legs: ::prost::alloc::vec::Vec<routing_summary::Leg>,
    /// A link to show directions on Google Maps using the waypoints from the given
    /// routing summary. The route generated by this link is not guaranteed to be
    /// the same as the route used to generate the routing summary.
    /// The link uses information provided in the request, from fields including
    /// `routingParameters` and `searchAlongRouteParameters` when applicable, to
    /// generate the directions link.
    #[prost(string, tag = "2")]
    pub directions_uri: ::prost::alloc::string::String,
}
/// Nested message and enum types in `RoutingSummary`.
pub mod routing_summary {
    /// A leg is a single portion of a journey from one location to another.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Leg {
        /// The time it takes to complete this leg of the trip.
        #[prost(message, optional, tag = "1")]
        pub duration: ::core::option::Option<::prost_types::Duration>,
        /// The distance of this leg of the trip.
        #[prost(int32, tag = "2")]
        pub distance_meters: i32,
    }
}
/// Travel mode options.
/// These options map to what [Routes API
/// offers](<https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteTravelMode>).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TravelMode {
    /// No travel mode specified. Defaults to `DRIVE`.
    Unspecified = 0,
    /// Travel by passenger car.
    Drive = 1,
    /// Travel by bicycle.  Not supported with `search_along_route_parameters`.
    Bicycle = 2,
    /// Travel by walking.  Not supported with `search_along_route_parameters`.
    Walk = 3,
    /// Motorized two wheeled vehicles of all kinds such as scooters and
    /// motorcycles. Note that this is distinct from the `BICYCLE` travel mode
    /// which covers human-powered transport.  Not supported with
    /// `search_along_route_parameters`. Only supported in those countries listed
    /// at [Countries and regions supported for two-wheeled
    /// vehicles](<https://developers.google.com/maps/documentation/routes/coverage-two-wheeled>).
    TwoWheeler = 4,
}
impl TravelMode {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "TRAVEL_MODE_UNSPECIFIED",
            Self::Drive => "DRIVE",
            Self::Bicycle => "BICYCLE",
            Self::Walk => "WALK",
            Self::TwoWheeler => "TWO_WHEELER",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "TRAVEL_MODE_UNSPECIFIED" => Some(Self::Unspecified),
            "DRIVE" => Some(Self::Drive),
            "BICYCLE" => Some(Self::Bicycle),
            "WALK" => Some(Self::Walk),
            "TWO_WHEELER" => Some(Self::TwoWheeler),
            _ => None,
        }
    }
}
/// Parameters to configure the routing calculations to the places in the
/// response, both along a route (where result ranking will be influenced) and
/// for calculating travel times on results.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct RoutingParameters {
    /// Optional. An explicit routing origin that overrides the origin defined in
    /// the polyline. By default, the polyline origin is used.
    #[prost(message, optional, tag = "1")]
    pub origin: ::core::option::Option<super::super::super::r#type::LatLng>,
    /// Optional. The travel mode.
    #[prost(enumeration = "TravelMode", tag = "2")]
    pub travel_mode: i32,
    /// Optional. The route modifiers.
    #[prost(message, optional, tag = "3")]
    pub route_modifiers: ::core::option::Option<RouteModifiers>,
    /// Optional. Specifies how to compute the routing summaries. The server
    /// attempts to use the selected routing preference to compute the route. The
    /// traffic aware routing preference is only available for the `DRIVE` or
    /// `TWO_WHEELER` `travelMode`.
    #[prost(enumeration = "RoutingPreference", tag = "4")]
    pub routing_preference: i32,
}
/// Request proto for Search Nearby.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchNearbyRequest {
    /// Place details will be displayed with the preferred language if available.
    /// If the language code is unspecified or unrecognized, place details of any
    /// language may be returned, with a preference for English if such details
    /// exist.
    ///
    /// Current list of supported languages:
    /// <https://developers.google.com/maps/faq#languagesupport.>
    #[prost(string, tag = "1")]
    pub language_code: ::prost::alloc::string::String,
    /// The Unicode country/region code (CLDR) of the location where the
    /// request is coming from. This parameter is used to display the place
    /// details, like region-specific place name, if available. The parameter can
    /// affect results based on applicable law.
    ///
    /// For more information, see
    /// <https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html.>
    ///
    /// Note that 3-digit region codes are not currently supported.
    #[prost(string, tag = "2")]
    pub region_code: ::prost::alloc::string::String,
    /// Included Place type (eg, "restaurant" or "gas_station") from
    /// <https://developers.google.com/maps/documentation/places/web-service/place-types.>
    ///
    /// Up to 50 types from [Table
    /// A](<https://developers.google.com/maps/documentation/places/web-service/place-types#table-a>)
    /// may be specified.
    ///
    /// If there are any conflicting types, i.e. a type appears in both
    /// included_types and excluded_types, an INVALID_ARGUMENT error is
    /// returned.
    ///
    /// If a Place type is specified with multiple type restrictions, only places
    /// that satisfy all of the restrictions are returned. For example, if we
    /// have {included_types = \["restaurant"\], excluded_primary_types =
    /// \["restaurant"\]}, the returned places provide "restaurant"
    /// related services but do not operate primarily as "restaurants".
    #[prost(string, repeated, tag = "3")]
    pub included_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Excluded Place type (eg, "restaurant" or "gas_station") from
    /// <https://developers.google.com/maps/documentation/places/web-service/place-types.>
    ///
    /// Up to 50 types from [Table
    /// A](<https://developers.google.com/maps/documentation/places/web-service/place-types#table-a>)
    /// may be specified.
    ///
    /// If the client provides both included_types (e.g. restaurant) and
    /// excluded_types (e.g. cafe), then the response should include places that
    /// are restaurant but not cafe. The response includes places that match at
    /// least one of the included_types and none of the excluded_types.
    ///
    /// If there are any conflicting types, i.e. a type appears in both
    /// included_types and excluded_types, an INVALID_ARGUMENT error is returned.
    ///
    /// If a Place type is specified with multiple type restrictions, only places
    /// that satisfy all of the restrictions are returned. For example, if we
    /// have {included_types = \["restaurant"\], excluded_primary_types =
    /// \["restaurant"\]}, the returned places provide "restaurant"
    /// related services but do not operate primarily as "restaurants".
    #[prost(string, repeated, tag = "4")]
    pub excluded_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Included primary Place type (e.g. "restaurant" or "gas_station") from
    /// <https://developers.google.com/maps/documentation/places/web-service/place-types.>
    /// A place can only have a single primary type from the supported types table
    /// associated with it.
    ///
    /// Up to 50 types from [Table
    /// A](<https://developers.google.com/maps/documentation/places/web-service/place-types#table-a>)
    /// may be specified.
    ///
    /// If there are any conflicting primary types, i.e. a type appears in both
    /// included_primary_types and excluded_primary_types, an INVALID_ARGUMENT
    /// error is returned.
    ///
    /// If a Place type is specified with multiple type restrictions, only places
    /// that satisfy all of the restrictions are returned. For example, if we
    /// have {included_types = \["restaurant"\], excluded_primary_types =
    /// \["restaurant"\]}, the returned places provide "restaurant"
    /// related services but do not operate primarily as "restaurants".
    #[prost(string, repeated, tag = "5")]
    pub included_primary_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Excluded primary Place type (e.g. "restaurant" or "gas_station") from
    /// <https://developers.google.com/maps/documentation/places/web-service/place-types.>
    ///
    /// Up to 50 types from [Table
    /// A](<https://developers.google.com/maps/documentation/places/web-service/place-types#table-a>)
    /// may be specified.
    ///
    /// If there are any conflicting primary types, i.e. a type appears in both
    /// included_primary_types and excluded_primary_types, an INVALID_ARGUMENT
    /// error is returned.
    ///
    /// If a Place type is specified with multiple type restrictions, only places
    /// that satisfy all of the restrictions are returned. For example, if we
    /// have {included_types = \["restaurant"\], excluded_primary_types =
    /// \["restaurant"\]}, the returned places provide "restaurant"
    /// related services but do not operate primarily as "restaurants".
    #[prost(string, repeated, tag = "6")]
    pub excluded_primary_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Maximum number of results to return. It must be between 1 and 20 (default),
    /// inclusively. If the number is unset, it falls back to the upper limit. If
    /// the number is set to negative or exceeds the upper limit, an
    /// INVALID_ARGUMENT error is returned.
    #[prost(int32, tag = "7")]
    pub max_result_count: i32,
    /// Required. The region to search.
    #[prost(message, optional, tag = "8")]
    pub location_restriction: ::core::option::Option<
        search_nearby_request::LocationRestriction,
    >,
    /// How results will be ranked in the response.
    #[prost(enumeration = "search_nearby_request::RankPreference", tag = "9")]
    pub rank_preference: i32,
    /// Optional. Parameters that affect the routing to the search results.
    #[prost(message, optional, tag = "10")]
    pub routing_parameters: ::core::option::Option<RoutingParameters>,
}
/// Nested message and enum types in `SearchNearbyRequest`.
pub mod search_nearby_request {
    /// The region to search.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct LocationRestriction {
        #[prost(oneof = "location_restriction::Type", tags = "2")]
        pub r#type: ::core::option::Option<location_restriction::Type>,
    }
    /// Nested message and enum types in `LocationRestriction`.
    pub mod location_restriction {
        #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
        pub enum Type {
            /// A circle defined by center point and radius.
            #[prost(message, tag = "2")]
            Circle(super::super::Circle),
        }
    }
    /// How results will be ranked in the response.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RankPreference {
        /// RankPreference value not set. Will use rank by POPULARITY by default.
        Unspecified = 0,
        /// Ranks results by distance.
        Distance = 1,
        /// Ranks results by popularity.
        Popularity = 2,
    }
    impl RankPreference {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "RANK_PREFERENCE_UNSPECIFIED",
                Self::Distance => "DISTANCE",
                Self::Popularity => "POPULARITY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RANK_PREFERENCE_UNSPECIFIED" => Some(Self::Unspecified),
                "DISTANCE" => Some(Self::Distance),
                "POPULARITY" => Some(Self::Popularity),
                _ => None,
            }
        }
    }
}
/// Response proto for Search Nearby.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchNearbyResponse {
    /// A list of places that meets user's requirements like places
    /// types, number of places and specific location restriction.
    #[prost(message, repeated, tag = "1")]
    pub places: ::prost::alloc::vec::Vec<Place>,
    /// A list of routing summaries where each entry associates to the
    /// corresponding place in the same index in the `places` field. If the routing
    /// summary is not available for one of the places, it will contain an empty
    /// entry. This list should have as many entries as the list of places if
    /// requested.
    #[prost(message, repeated, tag = "2")]
    pub routing_summaries: ::prost::alloc::vec::Vec<RoutingSummary>,
}
/// Request proto for SearchText.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchTextRequest {
    /// Required. The text query for textual search.
    #[prost(string, tag = "1")]
    pub text_query: ::prost::alloc::string::String,
    /// Place details will be displayed with the preferred language if available.
    /// If the language code is unspecified or unrecognized, place details of any
    /// language may be returned, with a preference for English if such details
    /// exist.
    ///
    /// Current list of supported languages:
    /// <https://developers.google.com/maps/faq#languagesupport.>
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
    /// The Unicode country/region code (CLDR) of the location where the
    /// request is coming from. This parameter is used to display the place
    /// details, like region-specific place name, if available. The parameter can
    /// affect results based on applicable law.
    ///
    /// For more information, see
    /// <https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html.>
    ///
    /// Note that 3-digit region codes are not currently supported.
    #[prost(string, tag = "3")]
    pub region_code: ::prost::alloc::string::String,
    /// How results will be ranked in the response.
    #[prost(enumeration = "search_text_request::RankPreference", tag = "4")]
    pub rank_preference: i32,
    /// The requested place type. Full list of types supported:
    /// <https://developers.google.com/maps/documentation/places/web-service/place-types.>
    /// Only support one included type.
    #[prost(string, tag = "6")]
    pub included_type: ::prost::alloc::string::String,
    /// Used to restrict the search to places that are currently open.  The default
    /// is false.
    #[prost(bool, tag = "7")]
    pub open_now: bool,
    /// Filter out results whose average user rating is strictly less than this
    /// limit. A valid value must be a float between 0 and 5 (inclusively) at a
    /// 0.5 cadence i.e. \[0, 0.5, 1.0, ... , 5.0\] inclusively. The input rating
    /// will round up to the nearest 0.5(ceiling). For instance, a rating of 0.6
    /// will eliminate all results with a less than 1.0 rating.
    #[prost(double, tag = "9")]
    pub min_rating: f64,
    /// Maximum number of results to return. It must be between 1 and 20,
    /// inclusively. The default is 20.  If the number is unset, it falls back to
    /// the upper limit. If the number is set to negative or exceeds the upper
    /// limit, an INVALID_ARGUMENT error is returned.
    #[prost(int32, tag = "10")]
    pub max_result_count: i32,
    /// Used to restrict the search to places that are marked as certain price
    /// levels. Users can choose any combinations of price levels. Default to
    /// select all price levels.
    #[prost(enumeration = "PriceLevel", repeated, tag = "11")]
    pub price_levels: ::prost::alloc::vec::Vec<i32>,
    /// Used to set strict type filtering for included_type. If set to true, only
    /// results of the same type will be returned. Default to false.
    #[prost(bool, tag = "12")]
    pub strict_type_filtering: bool,
    /// The region to search. This location serves as a bias which means results
    /// around given location might be returned. Cannot be set along with
    /// location_restriction.
    #[prost(message, optional, tag = "13")]
    pub location_bias: ::core::option::Option<search_text_request::LocationBias>,
    /// The region to search. This location serves as a restriction which means
    /// results outside given location will not be returned. Cannot be set along
    /// with location_bias.
    #[prost(message, optional, tag = "14")]
    pub location_restriction: ::core::option::Option<
        search_text_request::LocationRestriction,
    >,
    /// Optional. Set the searchable EV options of a place search request.
    #[prost(message, optional, tag = "15")]
    pub ev_options: ::core::option::Option<search_text_request::EvOptions>,
    /// Optional. Additional parameters for routing to results.
    #[prost(message, optional, tag = "16")]
    pub routing_parameters: ::core::option::Option<RoutingParameters>,
    /// Optional. Additional parameters proto for searching along a route.
    #[prost(message, optional, tag = "17")]
    pub search_along_route_parameters: ::core::option::Option<
        search_text_request::SearchAlongRouteParameters,
    >,
    /// Optional. Include pure service area businesses if the field is set to true.
    /// Pure service area business is a business that visits or delivers to
    /// customers directly but does not serve customers at their business address.
    /// For example, businesses like cleaning services or plumbers. Those
    /// businesses do not have a physical address or location on Google Maps.
    /// Places will not return fields including `location`, `plus_code`, and other
    /// location related fields for these businesses.
    #[prost(bool, tag = "20")]
    pub include_pure_service_area_businesses: bool,
}
/// Nested message and enum types in `SearchTextRequest`.
pub mod search_text_request {
    /// The region to search. This location serves as a bias which means results
    /// around given location might be returned.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct LocationBias {
        #[prost(oneof = "location_bias::Type", tags = "1, 2")]
        pub r#type: ::core::option::Option<location_bias::Type>,
    }
    /// Nested message and enum types in `LocationBias`.
    pub mod location_bias {
        #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
        pub enum Type {
            /// A rectangle 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.
            #[prost(message, tag = "1")]
            Rectangle(super::super::super::super::super::geo::r#type::Viewport),
            /// A circle defined by center point and radius.
            #[prost(message, tag = "2")]
            Circle(super::super::Circle),
        }
    }
    /// The region to search. This location serves as a restriction which means
    /// results outside given location will not be returned.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct LocationRestriction {
        #[prost(oneof = "location_restriction::Type", tags = "1")]
        pub r#type: ::core::option::Option<location_restriction::Type>,
    }
    /// Nested message and enum types in `LocationRestriction`.
    pub mod location_restriction {
        #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
        pub enum Type {
            /// A rectangle 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.
            #[prost(message, tag = "1")]
            Rectangle(super::super::super::super::super::geo::r#type::Viewport),
        }
    }
    /// Searchable EV options of a place search request.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct EvOptions {
        /// Optional. Minimum required charging rate in kilowatts. A place with a
        /// charging rate less than the specified rate is filtered out.
        #[prost(double, tag = "1")]
        pub minimum_charging_rate_kw: f64,
        /// Optional. The list of preferred EV connector types. A place that does not
        /// support any of the listed connector types is filtered out.
        #[prost(
            enumeration = "super::EvConnectorType",
            repeated,
            packed = "false",
            tag = "2"
        )]
        pub connector_types: ::prost::alloc::vec::Vec<i32>,
    }
    /// Specifies a precalculated polyline from the [Routes
    /// API](<https://developers.google.com/maps/documentation/routes>) defining the
    /// route to search. Searching along a route is similar to using the
    /// `locationBias` or `locationRestriction` request option to bias the search
    /// results. However, while the `locationBias` and `locationRestriction`
    /// options let you specify a region to bias the search results, this option
    /// lets you bias the results along a trip route.
    ///
    /// Results are not guaranteed to be along the route provided, but rather are
    /// ranked within the search area defined by the polyline and, optionally, by
    /// the `locationBias` or `locationRestriction` based on minimal detour times
    /// from origin to destination. The results might be along an alternate route,
    /// especially if the provided polyline does not define an optimal route from
    /// origin to destination.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct SearchAlongRouteParameters {
        /// Required. The route polyline.
        #[prost(message, optional, tag = "1")]
        pub polyline: ::core::option::Option<super::Polyline>,
    }
    /// How results will be ranked in the response.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RankPreference {
        /// For a categorical query such as "Restaurants in New York City", RELEVANCE
        /// is the default. For non-categorical queries such as "Mountain View, CA"
        /// we recommend that you leave rankPreference unset.
        Unspecified = 0,
        /// Ranks results by distance.
        Distance = 1,
        /// Ranks results by relevance. Sort order determined by normal ranking
        /// stack.
        Relevance = 2,
    }
    impl RankPreference {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "RANK_PREFERENCE_UNSPECIFIED",
                Self::Distance => "DISTANCE",
                Self::Relevance => "RELEVANCE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RANK_PREFERENCE_UNSPECIFIED" => Some(Self::Unspecified),
                "DISTANCE" => Some(Self::Distance),
                "RELEVANCE" => Some(Self::Relevance),
                _ => None,
            }
        }
    }
}
/// Response proto for SearchText.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SearchTextResponse {
    /// A list of places that meet the user's text search criteria.
    #[prost(message, repeated, tag = "1")]
    pub places: ::prost::alloc::vec::Vec<Place>,
    /// A list of routing summaries where each entry associates to the
    /// corresponding place in the same index in the `places` field. If the routing
    /// summary is not available for one of the places, it will contain an empty
    /// entry. This list will have as many entries as the list of places if
    /// requested.
    #[prost(message, repeated, tag = "2")]
    pub routing_summaries: ::prost::alloc::vec::Vec<RoutingSummary>,
    /// Experimental: See
    /// <https://developers.google.com/maps/documentation/places/web-service/experimental/places-generative>
    /// for more details.
    ///
    /// A list of contextual contents where each entry associates to the
    /// corresponding place in the same index in the places field. The contents
    /// that are relevant to the `text_query` in the request are preferred. If the
    /// contextual content is not available for one of the places, it will return
    /// non-contextual content. It will be empty only when the content is
    /// unavailable for this place. This list will have as many entries as the
    /// list of places if requested.
    #[prost(message, repeated, tag = "3")]
    pub contextual_contents: ::prost::alloc::vec::Vec<ContextualContent>,
}
/// Request for fetching a photo of a place using a photo resource name.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetPhotoMediaRequest {
    /// Required. The resource name of a photo media in the format:
    /// `places/{place_id}/photos/{photo_reference}/media`.
    ///
    /// The resource name of a photo as returned in a Place object's `photos.name`
    /// field comes with the format
    /// `places/{place_id}/photos/{photo_reference}`. You need to append `/media`
    /// at the end of the photo resource to get the photo media resource name.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Specifies the maximum desired width, in pixels, of the image. If
    /// the image is smaller than the values specified, the original image will be
    /// returned. If the image is larger in either dimension, it will be scaled to
    /// match the smaller of the two dimensions, restricted to its original aspect
    /// ratio. Both the max_height_px and max_width_px properties accept an integer
    /// between 1 and 4800, inclusively. If the value is not within the allowed
    /// range, an INVALID_ARGUMENT error will be returned.
    ///
    /// At least one of max_height_px or max_width_px needs to be specified. If
    /// neither max_height_px nor max_width_px is specified, an INVALID_ARGUMENT
    /// error will be returned.
    #[prost(int32, tag = "2")]
    pub max_width_px: i32,
    /// Optional. Specifies the maximum desired height, in pixels, of the image. If
    /// the image is smaller than the values specified, the original image will be
    /// returned. If the image is larger in either dimension, it will be scaled to
    /// match the smaller of the two dimensions, restricted to its original aspect
    /// ratio. Both the max_height_px and max_width_px properties accept an integer
    /// between 1 and 4800, inclusively. If the value is not within the allowed
    /// range, an INVALID_ARGUMENT error will be returned.
    ///
    /// At least one of max_height_px or max_width_px needs to be specified. If
    /// neither max_height_px nor max_width_px is specified, an INVALID_ARGUMENT
    /// error will be returned.
    #[prost(int32, tag = "3")]
    pub max_height_px: i32,
    /// Optional. If set, skip the default HTTP redirect behavior and render a text
    /// format (for example, in JSON format for HTTP use case) response. If not
    /// set, an HTTP redirect will be issued to redirect the call to the image
    /// media. This option is ignored for non-HTTP requests.
    #[prost(bool, tag = "4")]
    pub skip_http_redirect: bool,
}
/// A photo media from Places API.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PhotoMedia {
    /// The resource name of a photo media in the format:
    /// `places/{place_id}/photos/{photo_reference}/media`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// A short-lived uri that can be used to render the photo.
    #[prost(string, tag = "2")]
    pub photo_uri: ::prost::alloc::string::String,
}
/// Request for fetching a Place based on its resource name, which is a string in
/// the `places/{place_id}` format.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetPlaceRequest {
    /// Required. The resource name of a place, in the `places/{place_id}` format.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. Place details will be displayed with the preferred language if
    /// available.
    ///
    /// Current list of supported languages:
    /// <https://developers.google.com/maps/faq#languagesupport.>
    #[prost(string, tag = "2")]
    pub language_code: ::prost::alloc::string::String,
    /// Optional. The Unicode country/region code (CLDR) of the location where the
    /// request is coming from. This parameter is used to display the place
    /// details, like region-specific place name, if available. The parameter can
    /// affect results based on applicable law.
    /// For more information, see
    /// <https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html.>
    ///
    /// Note that 3-digit region codes are not currently supported.
    #[prost(string, tag = "3")]
    pub region_code: ::prost::alloc::string::String,
    /// Optional. A string which identifies an Autocomplete session for billing
    /// purposes. Must be a URL and filename safe base64 string with at most 36
    /// ASCII characters in length. Otherwise an INVALID_ARGUMENT error is
    /// returned.
    ///
    /// The session begins when the user starts typing a query, and concludes when
    /// they select a place and a call to Place Details or Address Validation is
    /// made. Each session can have multiple queries, followed by one Place Details
    /// or Address Validation request. The credentials used for each request within
    /// a session must belong to the same Google Cloud Console project. Once a
    /// session has concluded, the token is no longer valid; your app must generate
    /// a fresh token for each session. If the `session_token` parameter is
    /// omitted, or if you reuse a session token, the session is charged as if no
    /// session token was provided (each request is billed separately).
    ///
    /// We recommend the following guidelines:
    ///
    /// * Use session tokens for all Place Autocomplete calls.
    /// * Generate a fresh token for each session. Using a version 4 UUID is
    ///   recommended.
    /// * Ensure that the credentials used for all Place Autocomplete, Place
    ///   Details, and Address Validation requests within a session belong to the
    ///   same Cloud Console project.
    /// * Be sure to pass a unique session token for each new session. Using the
    ///   same token for more than one session will result in each request being
    ///   billed individually.
    #[prost(string, tag = "4")]
    pub session_token: ::prost::alloc::string::String,
}
/// Request proto for AutocompletePlaces.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutocompletePlacesRequest {
    /// Required. The text string on which to search.
    #[prost(string, tag = "1")]
    pub input: ::prost::alloc::string::String,
    /// Optional. Bias results to a specified location.
    ///
    /// At most one of `location_bias` or `location_restriction` should be set. If
    /// neither are set, the results will be biased by IP address, meaning the IP
    /// address will be mapped to an imprecise location and used as a biasing
    /// signal.
    #[prost(message, optional, tag = "2")]
    pub location_bias: ::core::option::Option<autocomplete_places_request::LocationBias>,
    /// Optional. Restrict results to a specified location.
    ///
    /// At most one of `location_bias` or `location_restriction` should be set. If
    /// neither are set, the results will be biased by IP address, meaning the IP
    /// address will be mapped to an imprecise location and used as a biasing
    /// signal.
    #[prost(message, optional, tag = "3")]
    pub location_restriction: ::core::option::Option<
        autocomplete_places_request::LocationRestriction,
    >,
    /// Optional. Included primary Place type (for example, "restaurant" or
    /// "gas_station") in Place Types
    /// (<https://developers.google.com/maps/documentation/places/web-service/place-types>),
    /// or only `(regions)`, or only `(cities)`. A Place is only returned if its
    /// primary type is included in this list. Up to 5 values can be specified. If
    /// no types are specified, all Place types are returned.
    #[prost(string, repeated, tag = "4")]
    pub included_primary_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Only include results in the specified regions, specified as up to
    /// 15 CLDR two-character region codes. An empty set will not restrict the
    /// results. If both `location_restriction` and `included_region_codes` are
    /// set, the results will be located in the area of intersection.
    #[prost(string, repeated, tag = "5")]
    pub included_region_codes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. The language in which to return results. Defaults to en-US. The
    /// results may be in mixed languages if the language used in `input` is
    /// different from `language_code` or if the returned Place does not have a
    /// translation from the local language to `language_code`.
    #[prost(string, tag = "6")]
    pub language_code: ::prost::alloc::string::String,
    /// Optional. The region code, specified as a CLDR two-character region code.
    /// This affects address formatting, result ranking, and may influence what
    /// results are returned. This does not restrict results to the specified
    /// region. To restrict results to a region, use `region_code_restriction`.
    #[prost(string, tag = "7")]
    pub region_code: ::prost::alloc::string::String,
    /// Optional. The origin point from which to calculate geodesic distance to the
    /// destination (returned as `distance_meters`). If this value is omitted,
    /// geodesic distance will not be returned.
    #[prost(message, optional, tag = "8")]
    pub origin: ::core::option::Option<super::super::super::r#type::LatLng>,
    /// Optional. A zero-based Unicode character offset of `input` indicating the
    /// cursor position in `input`. The cursor position may influence what
    /// predictions are returned.
    ///
    /// If empty, defaults to the length of `input`.
    #[prost(int32, tag = "9")]
    pub input_offset: i32,
    /// Optional. If true, the response will include both Place and query
    /// predictions. Otherwise the response will only return Place predictions.
    #[prost(bool, tag = "10")]
    pub include_query_predictions: bool,
    /// Optional. A string which identifies an Autocomplete session for billing
    /// purposes. Must be a URL and filename safe base64 string with at most 36
    /// ASCII characters in length. Otherwise an INVALID_ARGUMENT error is
    /// returned.
    ///
    /// The session begins when the user starts typing a query, and concludes when
    /// they select a place and a call to Place Details or Address Validation is
    /// made. Each session can have multiple queries, followed by one Place Details
    /// or Address Validation request. The credentials used for each request within
    /// a session must belong to the same Google Cloud Console project. Once a
    /// session has concluded, the token is no longer valid; your app must generate
    /// a fresh token for each session. If the `session_token` parameter is
    /// omitted, or if you reuse a session token, the session is charged as if no
    /// session token was provided (each request is billed separately).
    ///
    /// We recommend the following guidelines:
    ///
    /// * Use session tokens for all Place Autocomplete calls.
    /// * Generate a fresh token for each session. Using a version 4 UUID is
    ///   recommended.
    /// * Ensure that the credentials used for all Place Autocomplete, Place
    ///   Details, and Address Validation requests within a session belong to the
    ///   same Cloud Console project.
    /// * Be sure to pass a unique session token for each new session. Using the
    ///   same token for more than one session will result in each request being
    ///   billed individually.
    #[prost(string, tag = "11")]
    pub session_token: ::prost::alloc::string::String,
    /// Optional. Include pure service area businesses if the field is set to true.
    /// Pure service area business is a business that visits or delivers to
    /// customers directly but does not serve customers at their business address.
    /// For example, businesses like cleaning services or plumbers. Those
    /// businesses do not have a physical address or location on Google Maps.
    /// Places will not return fields including `location`, `plus_code`, and other
    /// location related fields for these businesses.
    #[prost(bool, tag = "12")]
    pub include_pure_service_area_businesses: bool,
}
/// Nested message and enum types in `AutocompletePlacesRequest`.
pub mod autocomplete_places_request {
    /// The region to search. The results may be biased around the specified
    /// region.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct LocationBias {
        #[prost(oneof = "location_bias::Type", tags = "1, 2")]
        pub r#type: ::core::option::Option<location_bias::Type>,
    }
    /// Nested message and enum types in `LocationBias`.
    pub mod location_bias {
        #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
        pub enum Type {
            /// A viewport defined by a northeast and a southwest corner.
            #[prost(message, tag = "1")]
            Rectangle(super::super::super::super::super::geo::r#type::Viewport),
            /// A circle defined by a center point and radius.
            #[prost(message, tag = "2")]
            Circle(super::super::Circle),
        }
    }
    /// The region to search. The results will be restricted to the specified
    /// region.
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct LocationRestriction {
        #[prost(oneof = "location_restriction::Type", tags = "1, 2")]
        pub r#type: ::core::option::Option<location_restriction::Type>,
    }
    /// Nested message and enum types in `LocationRestriction`.
    pub mod location_restriction {
        #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
        pub enum Type {
            /// A viewport defined by a northeast and a southwest corner.
            #[prost(message, tag = "1")]
            Rectangle(super::super::super::super::super::geo::r#type::Viewport),
            /// A circle defined by a center point and radius.
            #[prost(message, tag = "2")]
            Circle(super::super::Circle),
        }
    }
}
/// Response proto for AutocompletePlaces.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutocompletePlacesResponse {
    /// Contains a list of suggestions, ordered in descending order of relevance.
    #[prost(message, repeated, tag = "1")]
    pub suggestions: ::prost::alloc::vec::Vec<autocomplete_places_response::Suggestion>,
}
/// Nested message and enum types in `AutocompletePlacesResponse`.
pub mod autocomplete_places_response {
    /// An Autocomplete suggestion result.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Suggestion {
        #[prost(oneof = "suggestion::Kind", tags = "1, 2")]
        pub kind: ::core::option::Option<suggestion::Kind>,
    }
    /// Nested message and enum types in `Suggestion`.
    pub mod suggestion {
        /// Identifies a substring within a given text.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
        pub struct StringRange {
            /// Zero-based offset of the first Unicode character of the string
            /// (inclusive).
            #[prost(int32, tag = "1")]
            pub start_offset: i32,
            /// Zero-based offset of the last Unicode character (exclusive).
            #[prost(int32, tag = "2")]
            pub end_offset: i32,
        }
        /// Text representing a Place or query prediction. The text may be used as is
        /// or formatted.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct FormattableText {
            /// Text that may be used as is or formatted with `matches`.
            #[prost(string, tag = "1")]
            pub text: ::prost::alloc::string::String,
            /// A list of string ranges identifying where the input request matched in
            /// `text`. The ranges can be used to format specific parts of `text`. The
            /// substrings may not be exact matches of `input` if the matching was
            /// determined by criteria other than string matching (for example, spell
            /// corrections or transliterations).
            ///
            /// These values are Unicode character offsets of `text`. The ranges are
            /// guaranteed to be ordered in increasing offset values.
            #[prost(message, repeated, tag = "2")]
            pub matches: ::prost::alloc::vec::Vec<StringRange>,
        }
        /// Contains a breakdown of a Place or query prediction into main text
        /// and secondary text.
        ///
        /// For Place predictions, the main text contains the specific name of the
        /// Place. For query predictions, the main text contains the query.
        ///
        /// The secondary text contains additional disambiguating features (such as a
        /// city or region) to further identify the Place or refine the query.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct StructuredFormat {
            /// Represents the name of the Place or query.
            #[prost(message, optional, tag = "1")]
            pub main_text: ::core::option::Option<FormattableText>,
            /// Represents additional disambiguating features (such as a city or
            /// region) to further identify the Place or refine the query.
            #[prost(message, optional, tag = "2")]
            pub secondary_text: ::core::option::Option<FormattableText>,
        }
        /// Prediction results for a Place Autocomplete prediction.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct PlacePrediction {
            /// The resource name of the suggested Place. This name can be used in
            /// other APIs that accept Place names.
            #[prost(string, tag = "1")]
            pub place: ::prost::alloc::string::String,
            /// The unique identifier of the suggested Place. This identifier can be
            /// used in other APIs that accept Place IDs.
            #[prost(string, tag = "2")]
            pub place_id: ::prost::alloc::string::String,
            /// Contains the human-readable name for the returned result. For
            /// establishment results, this is usually the business name and address.
            ///
            /// `text` is recommended for developers who wish to show a single UI
            /// element. Developers who wish to show two separate, but related, UI
            /// elements may want to use `structured_format` instead. They are two
            /// different ways to represent a Place prediction. Users should not try to
            /// parse `structured_format` into `text` or vice versa.
            ///
            /// This text may be different from the `display_name` returned by
            /// GetPlace.
            ///
            /// May be in mixed languages if the request `input` and `language_code`
            /// are in different languages or if the Place does not have a translation
            /// from the local language to `language_code`.
            #[prost(message, optional, tag = "3")]
            pub text: ::core::option::Option<FormattableText>,
            /// A breakdown of the Place prediction into main text containing the name
            /// of the Place and secondary text containing additional disambiguating
            /// features (such as a city or region).
            ///
            /// `structured_format` is recommended for developers who wish to show two
            /// separate, but related, UI elements. Developers who wish to show a
            /// single UI element may want to use `text` instead. They are two
            /// different ways to represent a Place prediction. Users should not try to
            /// parse `structured_format` into `text` or vice versa.
            #[prost(message, optional, tag = "4")]
            pub structured_format: ::core::option::Option<StructuredFormat>,
            /// List of types that apply to this Place from Table A or Table B in
            /// <https://developers.google.com/maps/documentation/places/web-service/place-types.>
            ///
            /// A type is a categorization of a Place. Places with shared types will
            /// share similar characteristics.
            #[prost(string, repeated, tag = "5")]
            pub types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
            /// The length of the geodesic in meters from `origin` if `origin` is
            /// specified. Certain predictions such as routes may not populate this
            /// field.
            #[prost(int32, tag = "6")]
            pub distance_meters: i32,
        }
        /// Prediction results for a Query Autocomplete prediction.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct QueryPrediction {
            /// The predicted text. This text does not represent a Place, but rather a
            /// text query that could be used in a search endpoint (for example,
            /// Text Search).
            ///
            /// `text` is recommended for developers who wish to show a single UI
            /// element. Developers who wish to show two separate, but related, UI
            /// elements may want to use `structured_format` instead. They are two
            /// different ways to represent a query prediction. Users should not try to
            /// parse `structured_format` into `text` or vice versa.
            ///
            /// May be in mixed languages if the request `input` and `language_code`
            /// are in different languages or if part of the query does not have a
            /// translation from the local language to `language_code`.
            #[prost(message, optional, tag = "1")]
            pub text: ::core::option::Option<FormattableText>,
            /// A breakdown of the query prediction into main text containing the query
            /// and secondary text containing additional disambiguating features (such
            /// as a city or region).
            ///
            /// `structured_format` is recommended for developers who wish to show two
            /// separate, but related, UI elements. Developers who wish to show a
            /// single UI element may want to use `text` instead. They are two
            /// different ways to represent a query prediction. Users should not try to
            /// parse `structured_format` into `text` or vice versa.
            #[prost(message, optional, tag = "2")]
            pub structured_format: ::core::option::Option<StructuredFormat>,
        }
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Kind {
            /// A prediction for a Place.
            #[prost(message, tag = "1")]
            PlacePrediction(PlacePrediction),
            /// A prediction for a query.
            #[prost(message, tag = "2")]
            QueryPrediction(QueryPrediction),
        }
    }
}
/// Generated client implementations.
pub mod places_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service definition for the Places API.
    /// Note: every request (except for Autocomplete and GetPhotoMedia requests)
    /// requires a field mask set outside of the request proto (`all/*`, is not
    /// assumed). The field mask can be set via the HTTP header `X-Goog-FieldMask`.
    /// See:
    /// https://developers.google.com/maps/documentation/places/web-service/choose-fields
    #[derive(Debug, Clone)]
    pub struct PlacesClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl PlacesClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> PlacesClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> PlacesClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            PlacesClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Search for places near locations.
        pub async fn search_nearby(
            &mut self,
            request: impl tonic::IntoRequest<super::SearchNearbyRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SearchNearbyResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.maps.places.v1.Places/SearchNearby",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("google.maps.places.v1.Places", "SearchNearby"));
            self.inner.unary(req, path, codec).await
        }
        /// Text query based place search.
        pub async fn search_text(
            &mut self,
            request: impl tonic::IntoRequest<super::SearchTextRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SearchTextResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.maps.places.v1.Places/SearchText",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("google.maps.places.v1.Places", "SearchText"));
            self.inner.unary(req, path, codec).await
        }
        /// Get a photo media with a photo reference string.
        pub async fn get_photo_media(
            &mut self,
            request: impl tonic::IntoRequest<super::GetPhotoMediaRequest>,
        ) -> std::result::Result<tonic::Response<super::PhotoMedia>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.maps.places.v1.Places/GetPhotoMedia",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.maps.places.v1.Places", "GetPhotoMedia"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get the details of a place based on its resource name, which is a string
        /// in the `places/{place_id}` format.
        pub async fn get_place(
            &mut self,
            request: impl tonic::IntoRequest<super::GetPlaceRequest>,
        ) -> std::result::Result<tonic::Response<super::Place>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.maps.places.v1.Places/GetPlace",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("google.maps.places.v1.Places", "GetPlace"));
            self.inner.unary(req, path, codec).await
        }
        /// Returns predictions for the given input.
        pub async fn autocomplete_places(
            &mut self,
            request: impl tonic::IntoRequest<super::AutocompletePlacesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::AutocompletePlacesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.maps.places.v1.Places/AutocompletePlaces",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("google.maps.places.v1.Places", "AutocompletePlaces"),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
