google-maps-routing-v2 1.1.0

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

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

mod debug;
mod deserialize;
mod serialize;

/// Information related to how and why a fallback result was used. If this field
/// is set, then it means the server used a different routing mode from your
/// preferred mode as fallback.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FallbackInfo {
    /// Routing mode used for the response. If fallback was triggered, the mode
    /// may be different from routing preference set in the original client
    /// request.
    pub routing_mode: crate::model::FallbackRoutingMode,

    /// The reason why fallback response was used instead of the original response.
    /// This field is only populated when the fallback mode is triggered and the
    /// fallback response is returned.
    pub reason: crate::model::FallbackReason,

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

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

    /// Sets the value of [routing_mode][crate::model::FallbackInfo::routing_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::FallbackInfo;
    /// use google_maps_routing_v2::model::FallbackRoutingMode;
    /// let x0 = FallbackInfo::new().set_routing_mode(FallbackRoutingMode::FallbackTrafficUnaware);
    /// let x1 = FallbackInfo::new().set_routing_mode(FallbackRoutingMode::FallbackTrafficAware);
    /// ```
    pub fn set_routing_mode<T: std::convert::Into<crate::model::FallbackRoutingMode>>(
        mut self,
        v: T,
    ) -> Self {
        self.routing_mode = v.into();
        self
    }

    /// Sets the value of [reason][crate::model::FallbackInfo::reason].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::FallbackInfo;
    /// use google_maps_routing_v2::model::FallbackReason;
    /// let x0 = FallbackInfo::new().set_reason(FallbackReason::ServerError);
    /// let x1 = FallbackInfo::new().set_reason(FallbackReason::LatencyExceeded);
    /// ```
    pub fn set_reason<T: std::convert::Into<crate::model::FallbackReason>>(mut self, v: T) -> Self {
        self.reason = v.into();
        self
    }
}

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

/// Contains [`GeocodedWaypoints`][google.maps.routing.v2.GeocodedWaypoint] for
/// origin, destination and intermediate waypoints. Only populated for address
/// waypoints.
///
/// [google.maps.routing.v2.GeocodedWaypoint]: crate::model::GeocodedWaypoint
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GeocodingResults {
    /// Origin geocoded waypoint.
    pub origin: std::option::Option<crate::model::GeocodedWaypoint>,

    /// Destination geocoded waypoint.
    pub destination: std::option::Option<crate::model::GeocodedWaypoint>,

    /// A list of intermediate geocoded waypoints each containing an index field
    /// that corresponds to the zero-based position of the waypoint in the order
    /// they were specified in the request.
    pub intermediates: std::vec::Vec<crate::model::GeocodedWaypoint>,

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

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

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

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

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

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

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

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

/// Details about the locations used as waypoints. Only populated for address
/// waypoints. Includes details about the geocoding results for the purposes of
/// determining what the address was geocoded to.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GeocodedWaypoint {
    /// Indicates the status code resulting from the geocoding operation.
    pub geocoder_status: std::option::Option<google_cloud_rpc::model::Status>,

    /// The index of the corresponding intermediate waypoint in the request.
    /// Only populated if the corresponding waypoint is an intermediate
    /// waypoint.
    pub intermediate_waypoint_request_index: std::option::Option<i32>,

    /// The type(s) of the result, in the form of zero or more type tags.
    /// Supported types: [Address types and address component
    /// types](https://developers.google.com/maps/documentation/geocoding/requests-geocoding#Types).
    pub r#type: std::vec::Vec<std::string::String>,

    /// Indicates that the geocoder did not return an exact match for the original
    /// request, though it was able to match part of the requested address. You may
    /// wish to examine the original request for misspellings and/or an incomplete
    /// address.
    pub partial_match: bool,

    /// The place ID for this result.
    pub place_id: std::string::String,

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

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

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

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

    /// Sets the value of [intermediate_waypoint_request_index][crate::model::GeocodedWaypoint::intermediate_waypoint_request_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::GeocodedWaypoint;
    /// let x = GeocodedWaypoint::new().set_intermediate_waypoint_request_index(42);
    /// ```
    pub fn set_intermediate_waypoint_request_index<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.intermediate_waypoint_request_index = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [intermediate_waypoint_request_index][crate::model::GeocodedWaypoint::intermediate_waypoint_request_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::GeocodedWaypoint;
    /// let x = GeocodedWaypoint::new().set_or_clear_intermediate_waypoint_request_index(Some(42));
    /// let x = GeocodedWaypoint::new().set_or_clear_intermediate_waypoint_request_index(None::<i32>);
    /// ```
    pub fn set_or_clear_intermediate_waypoint_request_index<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.intermediate_waypoint_request_index = v.map(|x| x.into());
        self
    }

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

    /// Sets the value of [partial_match][crate::model::GeocodedWaypoint::partial_match].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::GeocodedWaypoint;
    /// let x = GeocodedWaypoint::new().set_partial_match(true);
    /// ```
    pub fn set_partial_match<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.partial_match = v.into();
        self
    }

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

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

/// Localized description of time.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LocalizedTime {
    /// The time specified as a string in a given time zone.
    pub time: std::option::Option<google_cloud_type::model::LocalizedText>,

    /// Contains the time zone. The value is the name of the time zone as defined
    /// in the [IANA Time Zone Database](http://www.iana.org/time-zones), e.g.
    /// "America/New_York".
    pub time_zone: std::string::String,

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

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

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

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

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

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

/// Encapsulates a location (a geographic point, and an optional heading).
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Location {
    /// The waypoint's geographic coordinates.
    pub lat_lng: std::option::Option<google_cloud_type::model::LatLng>,

    /// The compass heading associated with the direction of the flow of traffic.
    /// This value specifies the side of the road for pickup and drop-off. Heading
    /// values can be from 0 to 360, where 0 specifies a heading of due North, 90
    /// specifies a heading of due East, and so on. You can use this field only for
    /// `DRIVE` and `TWO_WHEELER`
    /// [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode].
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub heading: std::option::Option<wkt::Int32Value>,

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

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

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

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

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

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

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

/// Encapsulates navigation instructions for a
/// [`RouteLegStep`][google.maps.routing.v2.RouteLegStep].
///
/// [google.maps.routing.v2.RouteLegStep]: crate::model::RouteLegStep
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NavigationInstruction {
    /// Encapsulates the navigation instructions for the current step (for example,
    /// turn left, merge, or straight). This field determines which icon to
    /// display.
    pub maneuver: crate::model::Maneuver,

    /// Instructions for navigating this step.
    pub instructions: std::string::String,

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

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

    /// Sets the value of [maneuver][crate::model::NavigationInstruction::maneuver].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::NavigationInstruction;
    /// use google_maps_routing_v2::model::Maneuver;
    /// let x0 = NavigationInstruction::new().set_maneuver(Maneuver::TurnSlightLeft);
    /// let x1 = NavigationInstruction::new().set_maneuver(Maneuver::TurnSharpLeft);
    /// let x2 = NavigationInstruction::new().set_maneuver(Maneuver::UturnLeft);
    /// ```
    pub fn set_maneuver<T: std::convert::Into<crate::model::Maneuver>>(mut self, v: T) -> Self {
        self.maneuver = v.into();
        self
    }

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

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

/// Encapsulates an encoded polyline.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Polyline {
    /// Encapsulates the type of polyline. Defaults to encoded_polyline.
    pub polyline_type: std::option::Option<crate::model::polyline::PolylineType>,

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

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

    /// Sets the value of [polyline_type][crate::model::Polyline::polyline_type].
    ///
    /// Note that all the setters affecting `polyline_type` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::Polyline;
    /// use google_maps_routing_v2::model::polyline::PolylineType;
    /// let x = Polyline::new().set_polyline_type(Some(PolylineType::EncodedPolyline("example".to_string())));
    /// ```
    pub fn set_polyline_type<
        T: std::convert::Into<std::option::Option<crate::model::polyline::PolylineType>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.polyline_type = v.into();
        self
    }

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

    /// Sets the value of [polyline_type][crate::model::Polyline::polyline_type]
    /// to hold a `EncodedPolyline`.
    ///
    /// Note that all the setters affecting `polyline_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::Polyline;
    /// let x = Polyline::new().set_encoded_polyline("example");
    /// assert!(x.encoded_polyline().is_some());
    /// assert!(x.geo_json_linestring().is_none());
    /// ```
    pub fn set_encoded_polyline<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.polyline_type = std::option::Option::Some(
            crate::model::polyline::PolylineType::EncodedPolyline(v.into()),
        );
        self
    }

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

    /// Sets the value of [polyline_type][crate::model::Polyline::polyline_type]
    /// to hold a `GeoJsonLinestring`.
    ///
    /// Note that all the setters affecting `polyline_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::Polyline;
    /// use wkt::Struct;
    /// let x = Polyline::new().set_geo_json_linestring(Struct::default()/* use setters */);
    /// assert!(x.geo_json_linestring().is_some());
    /// assert!(x.encoded_polyline().is_none());
    /// ```
    pub fn set_geo_json_linestring<T: std::convert::Into<std::boxed::Box<wkt::Struct>>>(
        mut self,
        v: T,
    ) -> Self {
        self.polyline_type = std::option::Option::Some(
            crate::model::polyline::PolylineType::GeoJsonLinestring(v.into()),
        );
        self
    }
}

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

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

    /// Encapsulates the type of polyline. Defaults to encoded_polyline.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum PolylineType {
        /// The string encoding of the polyline using the [polyline encoding
        /// algorithm](https://developers.google.com/maps/documentation/utilities/polylinealgorithm)
        EncodedPolyline(std::string::String),
        /// Specifies a polyline using the [GeoJSON LineString
        /// format](https://tools.ietf.org/html/rfc7946#section-3.1.4).
        GeoJsonLinestring(std::boxed::Box<wkt::Struct>),
    }
}

/// Details corresponding to a given index or contiguous segment of a polyline.
/// Given a polyline with points P_0, P_1, ... , P_N (zero-based index), the
/// `PolylineDetails` defines an interval and associated metadata.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PolylineDetails {
    /// Tunnel details along the polyline. This field is populated if the request
    /// specifies the `avoid_tunnels` route modifier and the resultant route fails
    /// to avoid them, OR if `TUNNEL_INFO_ON_POLYLINE` is specified in
    /// `extra_computations` and the route contains tunnels.
    pub tunnel_info: std::vec::Vec<crate::model::polyline_details::TunnelInfo>,

    /// Flyover details along the polyline.
    pub flyover_info: std::vec::Vec<crate::model::polyline_details::FlyoverInfo>,

    /// Narrow road details along the polyline.
    pub narrow_road_info: std::vec::Vec<crate::model::polyline_details::NarrowRoadInfo>,

    /// Bridge details along the polyline.
    pub bridge_info: std::vec::Vec<crate::model::polyline_details::BridgeInfo>,

    /// Skyway details along the polyline.
    pub skyway_info: std::vec::Vec<crate::model::polyline_details::SkywayInfo>,

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

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

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

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

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

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

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

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

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

    /// Encapsulates the start and end indexes for a polyline detail.
    /// For instances where the data corresponds to a single point, `start_index`
    /// and `end_index` will be equal.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct PolylinePointIndex {
        /// The start index of this detail in the polyline.
        pub start_index: std::option::Option<i32>,

        /// The end index of this detail in the polyline.
        pub end_index: std::option::Option<i32>,

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

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

        /// Sets the value of [start_index][crate::model::polyline_details::PolylinePointIndex::start_index].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_routing_v2::model::polyline_details::PolylinePointIndex;
        /// let x = PolylinePointIndex::new().set_start_index(42);
        /// ```
        pub fn set_start_index<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i32>,
        {
            self.start_index = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [start_index][crate::model::polyline_details::PolylinePointIndex::start_index].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_routing_v2::model::polyline_details::PolylinePointIndex;
        /// let x = PolylinePointIndex::new().set_or_clear_start_index(Some(42));
        /// let x = PolylinePointIndex::new().set_or_clear_start_index(None::<i32>);
        /// ```
        pub fn set_or_clear_start_index<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<i32>,
        {
            self.start_index = v.map(|x| x.into());
            self
        }

        /// Sets the value of [end_index][crate::model::polyline_details::PolylinePointIndex::end_index].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_routing_v2::model::polyline_details::PolylinePointIndex;
        /// let x = PolylinePointIndex::new().set_end_index(42);
        /// ```
        pub fn set_end_index<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i32>,
        {
            self.end_index = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [end_index][crate::model::polyline_details::PolylinePointIndex::end_index].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_routing_v2::model::polyline_details::PolylinePointIndex;
        /// let x = PolylinePointIndex::new().set_or_clear_end_index(Some(42));
        /// let x = PolylinePointIndex::new().set_or_clear_end_index(None::<i32>);
        /// ```
        pub fn set_or_clear_end_index<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<i32>,
        {
            self.end_index = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for PolylinePointIndex {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.routing.v2.PolylineDetails.PolylinePointIndex"
        }
    }

    /// Encapsulates information about tunnels along the polyline.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct TunnelInfo {
        /// Denotes whether a tunnel exists for a given stretch of the polyline.
        pub tunnel_presence: crate::model::polyline_details::RoadFeatureState,

        /// The location of tunnel related information along the polyline.
        pub polyline_point_index:
            std::option::Option<crate::model::polyline_details::PolylinePointIndex>,

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

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

        /// Sets the value of [tunnel_presence][crate::model::polyline_details::TunnelInfo::tunnel_presence].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_routing_v2::model::polyline_details::TunnelInfo;
        /// use google_maps_routing_v2::model::polyline_details::RoadFeatureState;
        /// let x0 = TunnelInfo::new().set_tunnel_presence(RoadFeatureState::Exists);
        /// let x1 = TunnelInfo::new().set_tunnel_presence(RoadFeatureState::DoesNotExist);
        /// ```
        pub fn set_tunnel_presence<
            T: std::convert::Into<crate::model::polyline_details::RoadFeatureState>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.tunnel_presence = v.into();
            self
        }

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

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

    impl wkt::message::Message for TunnelInfo {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.routing.v2.PolylineDetails.TunnelInfo"
        }
    }

    /// Encapsulates information about bridges along the polyline.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct BridgeInfo {
        /// Denotes whether a bridge exists for a given stretch of the polyline.
        pub bridge_presence: crate::model::polyline_details::RoadFeatureState,

        /// The location of bridge related information along the polyline.
        pub polyline_point_index:
            std::option::Option<crate::model::polyline_details::PolylinePointIndex>,

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

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

        /// Sets the value of [bridge_presence][crate::model::polyline_details::BridgeInfo::bridge_presence].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_routing_v2::model::polyline_details::BridgeInfo;
        /// use google_maps_routing_v2::model::polyline_details::RoadFeatureState;
        /// let x0 = BridgeInfo::new().set_bridge_presence(RoadFeatureState::Exists);
        /// let x1 = BridgeInfo::new().set_bridge_presence(RoadFeatureState::DoesNotExist);
        /// ```
        pub fn set_bridge_presence<
            T: std::convert::Into<crate::model::polyline_details::RoadFeatureState>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.bridge_presence = v.into();
            self
        }

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

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

    impl wkt::message::Message for BridgeInfo {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.routing.v2.PolylineDetails.BridgeInfo"
        }
    }

    /// Encapsulates information about skyways along the polyline.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct SkywayInfo {
        /// Denotes whether a skyway exists for a given stretch of the polyline.
        pub skyway_presence: crate::model::polyline_details::RoadFeatureState,

        /// The location of skyway related information along the polyline.
        pub polyline_point_index:
            std::option::Option<crate::model::polyline_details::PolylinePointIndex>,

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

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

        /// Sets the value of [skyway_presence][crate::model::polyline_details::SkywayInfo::skyway_presence].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_routing_v2::model::polyline_details::SkywayInfo;
        /// use google_maps_routing_v2::model::polyline_details::RoadFeatureState;
        /// let x0 = SkywayInfo::new().set_skyway_presence(RoadFeatureState::Exists);
        /// let x1 = SkywayInfo::new().set_skyway_presence(RoadFeatureState::DoesNotExist);
        /// ```
        pub fn set_skyway_presence<
            T: std::convert::Into<crate::model::polyline_details::RoadFeatureState>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.skyway_presence = v.into();
            self
        }

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

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

    impl wkt::message::Message for SkywayInfo {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.routing.v2.PolylineDetails.SkywayInfo"
        }
    }

    /// Encapsulates information about flyovers along the polyline.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct FlyoverInfo {
        /// Output only. Denotes whether a flyover exists for a given stretch of the
        /// polyline.
        pub flyover_presence: crate::model::polyline_details::RoadFeatureState,

        /// The location of flyover related information along the polyline.
        pub polyline_point_index:
            std::option::Option<crate::model::polyline_details::PolylinePointIndex>,

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

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

        /// Sets the value of [flyover_presence][crate::model::polyline_details::FlyoverInfo::flyover_presence].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_routing_v2::model::polyline_details::FlyoverInfo;
        /// use google_maps_routing_v2::model::polyline_details::RoadFeatureState;
        /// let x0 = FlyoverInfo::new().set_flyover_presence(RoadFeatureState::Exists);
        /// let x1 = FlyoverInfo::new().set_flyover_presence(RoadFeatureState::DoesNotExist);
        /// ```
        pub fn set_flyover_presence<
            T: std::convert::Into<crate::model::polyline_details::RoadFeatureState>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.flyover_presence = v.into();
            self
        }

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

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

    impl wkt::message::Message for FlyoverInfo {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.routing.v2.PolylineDetails.FlyoverInfo"
        }
    }

    /// Encapsulates information about narrow roads along the polyline.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct NarrowRoadInfo {
        /// Output only. Denotes whether a narrow road exists for a given stretch of
        /// the polyline.
        pub narrow_road_presence: crate::model::polyline_details::RoadFeatureState,

        /// The location of narrow road related information along the polyline.
        pub polyline_point_index:
            std::option::Option<crate::model::polyline_details::PolylinePointIndex>,

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

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

        /// Sets the value of [narrow_road_presence][crate::model::polyline_details::NarrowRoadInfo::narrow_road_presence].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_maps_routing_v2::model::polyline_details::NarrowRoadInfo;
        /// use google_maps_routing_v2::model::polyline_details::RoadFeatureState;
        /// let x0 = NarrowRoadInfo::new().set_narrow_road_presence(RoadFeatureState::Exists);
        /// let x1 = NarrowRoadInfo::new().set_narrow_road_presence(RoadFeatureState::DoesNotExist);
        /// ```
        pub fn set_narrow_road_presence<
            T: std::convert::Into<crate::model::polyline_details::RoadFeatureState>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.narrow_road_presence = v.into();
            self
        }

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

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

    impl wkt::message::Message for NarrowRoadInfo {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.routing.v2.PolylineDetails.NarrowRoadInfo"
        }
    }

    /// Encapsulates the states of road features along a stretch of polyline.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum RoadFeatureState {
        /// The road feature's state was not computed (default value).
        Unspecified,
        /// The road feature exists.
        Exists,
        /// The road feature does not exist.
        DoesNotExist,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [RoadFeatureState::value] or
        /// [RoadFeatureState::name].
        UnknownValue(road_feature_state::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for RoadFeatureState {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Exists,
                2 => Self::DoesNotExist,
                _ => Self::UnknownValue(road_feature_state::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for RoadFeatureState {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "ROAD_FEATURE_STATE_UNSPECIFIED" => Self::Unspecified,
                "EXISTS" => Self::Exists,
                "DOES_NOT_EXIST" => Self::DoesNotExist,
                _ => Self::UnknownValue(road_feature_state::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// Contains a route, which consists of a series of connected road segments
/// that join beginning, ending, and intermediate waypoints.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Route {
    /// Labels for the `Route` that are useful to identify specific properties
    /// of the route to compare against others.
    pub route_labels: std::vec::Vec<crate::model::RouteLabel>,

    /// A collection of legs (path segments between waypoints) that make up the
    /// route. Each leg corresponds to the trip between two non-`via`
    /// [`Waypoints`][google.maps.routing.v2.Waypoint]. For example, a route with
    /// no intermediate waypoints has only one leg. A route that includes one
    /// non-`via` intermediate waypoint has two legs. A route that includes one
    /// `via` intermediate waypoint has one leg. The order of the legs matches the
    /// order of waypoints from `origin` to `intermediates` to `destination`.
    ///
    /// [google.maps.routing.v2.Waypoint]: crate::model::Waypoint
    pub legs: std::vec::Vec<crate::model::RouteLeg>,

    /// The travel distance of the route, in meters.
    pub distance_meters: i32,

    /// The length of time needed to navigate the route. If you set the
    /// `routing_preference` to `TRAFFIC_UNAWARE`, then this value is the same as
    /// `static_duration`. If you set the `routing_preference` to either
    /// `TRAFFIC_AWARE` or `TRAFFIC_AWARE_OPTIMAL`, then this value is calculated
    /// taking traffic conditions into account.
    pub duration: std::option::Option<wkt::Duration>,

    /// The duration of travel through the route without taking traffic
    /// conditions into consideration.
    pub static_duration: std::option::Option<wkt::Duration>,

    /// The overall route polyline. This polyline is the combined polyline of
    /// all `legs`.
    pub polyline: std::option::Option<crate::model::Polyline>,

    /// A description of the route.
    pub description: std::string::String,

    /// An array of warnings to show when displaying the route.
    pub warnings: std::vec::Vec<std::string::String>,

    /// The viewport bounding box of the polyline.
    pub viewport: std::option::Option<google_geo_type::model::Viewport>,

    /// Additional information about the route.
    pub travel_advisory: std::option::Option<crate::model::RouteTravelAdvisory>,

    /// If you set
    /// [`optimize_waypoint_order`][google.maps.routing.v2.ComputeRoutesRequest.optimize_waypoint_order]
    /// to true, this field contains the optimized ordering of intermediate
    /// waypoints. Otherwise, this field is empty.
    /// For example, if you give an input of Origin: LA; Intermediate waypoints:
    /// Dallas, Bangor, Phoenix; Destination: New York; and the optimized
    /// intermediate waypoint order is Phoenix, Dallas, Bangor, then this field
    /// contains the values [2, 0, 1]. The index starts with 0 for the first
    /// intermediate waypoint provided in the input.
    ///
    /// [google.maps.routing.v2.ComputeRoutesRequest.optimize_waypoint_order]: crate::model::ComputeRoutesRequest::optimize_waypoint_order
    pub optimized_intermediate_waypoint_index: std::vec::Vec<i32>,

    /// Text representations of properties of the `Route`.
    pub localized_values: std::option::Option<crate::model::route::RouteLocalizedValues>,

    /// An opaque token that can be passed to [Navigation
    /// SDK](https://developers.google.com/maps/documentation/mobility/driver-sdk/navigation)
    /// to reconstruct the route during navigation, and, in the event of rerouting,
    /// honor the original intention when the route was created. Treat this token
    /// as an opaque blob.  Don't compare its value across requests as its value
    /// may change even if the service returns the exact same route.
    ///
    /// NOTE: `Route.route_token` is only available for requests that have set
    /// `ComputeRoutesRequest.routing_preference` to `TRAFFIC_AWARE` or
    /// `TRAFFIC_AWARE_OPTIMAL`. `Route.route_token` is not supported for requests
    /// that have Via waypoints.
    pub route_token: std::string::String,

    /// Contains information about details along the polyline.
    pub polyline_details: std::option::Option<crate::model::PolylineDetails>,

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

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

    /// Sets the value of [route_labels][crate::model::Route::route_labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::Route;
    /// use google_maps_routing_v2::model::RouteLabel;
    /// let x = Route::new().set_route_labels([
    ///     RouteLabel::DefaultRoute,
    ///     RouteLabel::DefaultRouteAlternate,
    ///     RouteLabel::FuelEfficient,
    /// ]);
    /// ```
    pub fn set_route_labels<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::RouteLabel>,
    {
        use std::iter::Iterator;
        self.route_labels = v.into_iter().map(|i| i.into()).collect();
        self
    }

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

    /// Sets the value of [distance_meters][crate::model::Route::distance_meters].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::Route;
    /// let x = Route::new().set_distance_meters(42);
    /// ```
    pub fn set_distance_meters<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.distance_meters = v.into();
        self
    }

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

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

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

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

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

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

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

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

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

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

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

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

    /// Sets the value of [optimized_intermediate_waypoint_index][crate::model::Route::optimized_intermediate_waypoint_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::Route;
    /// let x = Route::new().set_optimized_intermediate_waypoint_index([1, 2, 3]);
    /// ```
    pub fn set_optimized_intermediate_waypoint_index<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<i32>,
    {
        use std::iter::Iterator;
        self.optimized_intermediate_waypoint_index = v.into_iter().map(|i| i.into()).collect();
        self
    }

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

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

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

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

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

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

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

    /// Text representations of certain properties.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct RouteLocalizedValues {
        /// Travel distance represented in text form.
        pub distance: std::option::Option<google_cloud_type::model::LocalizedText>,

        /// Duration, represented in text form and localized to the region of the
        /// query. Takes traffic conditions into consideration. Note: If you did not
        /// request traffic information, this value is the same value as
        /// `static_duration`.
        pub duration: std::option::Option<google_cloud_type::model::LocalizedText>,

        /// Duration without taking traffic conditions into consideration,
        /// represented in text form.
        pub static_duration: std::option::Option<google_cloud_type::model::LocalizedText>,

        /// Transit fare represented in text form.
        pub transit_fare: std::option::Option<google_cloud_type::model::LocalizedText>,

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

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

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

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

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

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

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

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

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

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

    impl wkt::message::Message for RouteLocalizedValues {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.routing.v2.Route.RouteLocalizedValues"
        }
    }
}

/// Contains the additional information that the user should be informed
/// about, such as possible traffic zone restrictions.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RouteTravelAdvisory {
    /// Contains information about tolls on the route. This field is only populated
    /// if tolls are expected on the route and `TOLLS` is included in the request's
    /// [ComputeRoutesRequest.extra_computations][google.maps.routing.v2.ComputeRoutesRequest.extra_computations].
    /// If this field is set, but the `estimatedPrice` subfield is not populated,
    /// then the route contains tolls, but the estimated price is unknown. If
    /// `toll_info` is not set, then there are no tolls expected on the route.
    ///
    /// [google.maps.routing.v2.ComputeRoutesRequest.extra_computations]: crate::model::ComputeRoutesRequest::extra_computations
    pub toll_info: std::option::Option<crate::model::TollInfo>,

    /// Speed reading intervals indicating traffic density. This field is only
    /// populated for requests when the request has a `TRAFFIC_AWARE` or
    /// `TRAFFIC_AWARE_OPTIMAL`
    /// [ComputeRoutesRequest.routing_preference][google.maps.routing.v2.ComputeRoutesRequest.routing_preference]
    /// value, and `TRAFFIC_ON_POLYLINE` is included in the
    /// [ComputeRoutesRequest.extra_computations][google.maps.routing.v2.ComputeRoutesRequest.extra_computations].
    /// The intervals cover the entire polyline of the route without overlap. The
    /// start point of a specified interval is the same as the end point of the
    /// preceding interval.
    ///
    /// Example:
    ///
    /// ```norust
    /// polyline: A ---- B ---- C ---- D ---- E ---- F ---- G
    /// speed_reading_intervals: [A,C), [C,D), [D,G).
    /// ```
    ///
    /// [google.maps.routing.v2.ComputeRoutesRequest.extra_computations]: crate::model::ComputeRoutesRequest::extra_computations
    /// [google.maps.routing.v2.ComputeRoutesRequest.routing_preference]: crate::model::ComputeRoutesRequest::routing_preference
    pub speed_reading_intervals: std::vec::Vec<crate::model::SpeedReadingInterval>,

    /// The predicted fuel consumption in microliters.
    /// This field is only populated when `FUEL_CONSUMPTION` is included in the
    /// request's
    /// [ComputeRoutesRequest.extra_computations][google.maps.routing.v2.ComputeRoutesRequest.extra_computations].
    ///
    /// [google.maps.routing.v2.ComputeRoutesRequest.extra_computations]: crate::model::ComputeRoutesRequest::extra_computations
    pub fuel_consumption_microliters: i64,

    /// Returned route may have restrictions that are not suitable for requested
    /// travel mode or route modifiers.
    pub route_restrictions_partially_ignored: bool,

    /// If present, contains the total fare or ticket costs on this route
    /// This property is only returned for `TRANSIT` requests and only
    /// for routes where fare information is available for all transit steps.
    pub transit_fare: std::option::Option<google_cloud_type::model::Money>,

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

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

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

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

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

    /// Sets the value of [fuel_consumption_microliters][crate::model::RouteTravelAdvisory::fuel_consumption_microliters].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteTravelAdvisory;
    /// let x = RouteTravelAdvisory::new().set_fuel_consumption_microliters(42);
    /// ```
    pub fn set_fuel_consumption_microliters<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.fuel_consumption_microliters = v.into();
        self
    }

    /// Sets the value of [route_restrictions_partially_ignored][crate::model::RouteTravelAdvisory::route_restrictions_partially_ignored].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteTravelAdvisory;
    /// let x = RouteTravelAdvisory::new().set_route_restrictions_partially_ignored(true);
    /// ```
    pub fn set_route_restrictions_partially_ignored<T: std::convert::Into<bool>>(
        mut self,
        v: T,
    ) -> Self {
        self.route_restrictions_partially_ignored = v.into();
        self
    }

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

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

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

/// Contains the additional information that the user should be informed
/// about on a leg step, such as possible traffic zone restrictions.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RouteLegTravelAdvisory {
    /// Contains information about tolls on the specific `RouteLeg`.
    /// This field is only populated if we expect there are tolls on the
    /// `RouteLeg` and `TOLLS` is included in the request's
    /// [ComputeRoutesRequest.extra_computations][google.maps.routing.v2.ComputeRoutesRequest.extra_computations].
    /// If this field is set but the estimated_price subfield is not
    /// populated, we expect that road contains tolls but we do not know an
    /// estimated price. If `toll_info` does not exist, then there is no toll on
    /// the `RouteLeg`.
    ///
    /// [google.maps.routing.v2.ComputeRoutesRequest.extra_computations]: crate::model::ComputeRoutesRequest::extra_computations
    pub toll_info: std::option::Option<crate::model::TollInfo>,

    /// Speed reading intervals indicating traffic density. This field is only
    /// populated for requests when the request has a `TRAFFIC_AWARE` or
    /// `TRAFFIC_AWARE_OPTIMAL`
    /// [ComputeRoutesRequest.routing_preference][google.maps.routing.v2.ComputeRoutesRequest.routing_preference]
    /// value, and `TRAFFIC_ON_POLYLINE` is included in the
    /// [ComputeRoutesRequest.extra_computations][google.maps.routing.v2.ComputeRoutesRequest.extra_computations].
    /// The intervals cover the entire polyline of the `RouteLeg` without overlap.
    /// The start point of a specified interval is the same as the end point of the
    /// preceding interval.
    ///
    /// Example:
    ///
    /// ```norust
    /// polyline: A ---- B ---- C ---- D ---- E ---- F ---- G
    /// speed_reading_intervals: [A,C), [C,D), [D,G).
    /// ```
    ///
    /// [google.maps.routing.v2.ComputeRoutesRequest.extra_computations]: crate::model::ComputeRoutesRequest::extra_computations
    /// [google.maps.routing.v2.ComputeRoutesRequest.routing_preference]: crate::model::ComputeRoutesRequest::routing_preference
    pub speed_reading_intervals: std::vec::Vec<crate::model::SpeedReadingInterval>,

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

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

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

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

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

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

/// Contains the additional information that the user should be informed
/// about, such as possible traffic zone restrictions on a leg step.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RouteLegStepTravelAdvisory {
    /// NOTE: This field is not currently populated.
    pub speed_reading_intervals: std::vec::Vec<crate::model::SpeedReadingInterval>,

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

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

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

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

/// Contains a segment between non-`via` waypoints.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RouteLeg {
    /// The travel distance of the route leg, in meters.
    pub distance_meters: i32,

    /// The length of time needed to navigate the leg. If the `route_preference`
    /// is set to `TRAFFIC_UNAWARE`, then this value is the same as
    /// `static_duration`. If the `route_preference` is either `TRAFFIC_AWARE` or
    /// `TRAFFIC_AWARE_OPTIMAL`, then this value is calculated taking traffic
    /// conditions into account.
    pub duration: std::option::Option<wkt::Duration>,

    /// The duration of travel through the leg, calculated without taking
    /// traffic conditions into consideration.
    pub static_duration: std::option::Option<wkt::Duration>,

    /// The overall polyline for this leg that includes each `step`'s
    /// polyline.
    pub polyline: std::option::Option<crate::model::Polyline>,

    /// The start location of this leg. This location might be different from the
    /// provided `origin`. For example, when the provided `origin` is not near a
    /// road, this is a point on the road.
    pub start_location: std::option::Option<crate::model::Location>,

    /// The end location of this leg. This location might be different from the
    /// provided `destination`. For example, when the provided `destination` is not
    /// near a road, this is a point on the road.
    pub end_location: std::option::Option<crate::model::Location>,

    /// An array of steps denoting segments within this leg. Each step represents
    /// one navigation instruction.
    pub steps: std::vec::Vec<crate::model::RouteLegStep>,

    /// Contains the additional information that the user should be informed
    /// about, such as possible traffic zone restrictions, on a route leg.
    pub travel_advisory: std::option::Option<crate::model::RouteLegTravelAdvisory>,

    /// Text representations of properties of the `RouteLeg`.
    pub localized_values: std::option::Option<crate::model::route_leg::RouteLegLocalizedValues>,

    /// Overview information about the steps in this `RouteLeg`. This field is only
    /// populated for TRANSIT routes.
    pub steps_overview: std::option::Option<crate::model::route_leg::StepsOverview>,

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

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

    /// Sets the value of [distance_meters][crate::model::RouteLeg::distance_meters].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteLeg;
    /// let x = RouteLeg::new().set_distance_meters(42);
    /// ```
    pub fn set_distance_meters<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.distance_meters = v.into();
        self
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Text representations of certain properties.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct RouteLegLocalizedValues {
        /// Travel distance represented in text form.
        pub distance: std::option::Option<google_cloud_type::model::LocalizedText>,

        /// Duration, represented in text form and localized to the region of the
        /// query. Takes traffic conditions into consideration. Note: If you did not
        /// request traffic information, this value is the same value as
        /// static_duration.
        pub duration: std::option::Option<google_cloud_type::model::LocalizedText>,

        /// Duration without taking traffic conditions into
        /// consideration, represented in text form.
        pub static_duration: std::option::Option<google_cloud_type::model::LocalizedText>,

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

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

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

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

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

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

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

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

    impl wkt::message::Message for RouteLegLocalizedValues {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.routing.v2.RouteLeg.RouteLegLocalizedValues"
        }
    }

    /// Provides overview information about a list of `RouteLegStep`s.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct StepsOverview {
        /// Summarized information about different multi-modal segments of
        /// the `RouteLeg.steps`. This field is not populated if the `RouteLeg` does
        /// not contain any multi-modal segments in the steps.
        pub multi_modal_segments:
            std::vec::Vec<crate::model::route_leg::steps_overview::MultiModalSegment>,

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

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

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

    impl wkt::message::Message for StepsOverview {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.routing.v2.RouteLeg.StepsOverview"
        }
    }

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

        /// Provides summarized information about different multi-modal segments of
        /// the `RouteLeg.steps`. A multi-modal segment is defined as one or more
        /// contiguous `RouteLegStep` that have the same `RouteTravelMode`.
        /// This field is not populated if the `RouteLeg` does not contain any
        /// multi-modal segments in the steps.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct MultiModalSegment {
            /// The corresponding `RouteLegStep` index that is the start of a
            /// multi-modal segment.
            pub step_start_index: std::option::Option<i32>,

            /// The corresponding `RouteLegStep` index that is the end of a
            /// multi-modal segment.
            pub step_end_index: std::option::Option<i32>,

            /// NavigationInstruction for the multi-modal segment.
            pub navigation_instruction: std::option::Option<crate::model::NavigationInstruction>,

            /// The travel mode of the multi-modal segment.
            pub travel_mode: crate::model::RouteTravelMode,

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

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

            /// Sets the value of [step_start_index][crate::model::route_leg::steps_overview::MultiModalSegment::step_start_index].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_maps_routing_v2::model::route_leg::steps_overview::MultiModalSegment;
            /// let x = MultiModalSegment::new().set_step_start_index(42);
            /// ```
            pub fn set_step_start_index<T>(mut self, v: T) -> Self
            where
                T: std::convert::Into<i32>,
            {
                self.step_start_index = std::option::Option::Some(v.into());
                self
            }

            /// Sets or clears the value of [step_start_index][crate::model::route_leg::steps_overview::MultiModalSegment::step_start_index].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_maps_routing_v2::model::route_leg::steps_overview::MultiModalSegment;
            /// let x = MultiModalSegment::new().set_or_clear_step_start_index(Some(42));
            /// let x = MultiModalSegment::new().set_or_clear_step_start_index(None::<i32>);
            /// ```
            pub fn set_or_clear_step_start_index<T>(mut self, v: std::option::Option<T>) -> Self
            where
                T: std::convert::Into<i32>,
            {
                self.step_start_index = v.map(|x| x.into());
                self
            }

            /// Sets the value of [step_end_index][crate::model::route_leg::steps_overview::MultiModalSegment::step_end_index].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_maps_routing_v2::model::route_leg::steps_overview::MultiModalSegment;
            /// let x = MultiModalSegment::new().set_step_end_index(42);
            /// ```
            pub fn set_step_end_index<T>(mut self, v: T) -> Self
            where
                T: std::convert::Into<i32>,
            {
                self.step_end_index = std::option::Option::Some(v.into());
                self
            }

            /// Sets or clears the value of [step_end_index][crate::model::route_leg::steps_overview::MultiModalSegment::step_end_index].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_maps_routing_v2::model::route_leg::steps_overview::MultiModalSegment;
            /// let x = MultiModalSegment::new().set_or_clear_step_end_index(Some(42));
            /// let x = MultiModalSegment::new().set_or_clear_step_end_index(None::<i32>);
            /// ```
            pub fn set_or_clear_step_end_index<T>(mut self, v: std::option::Option<T>) -> Self
            where
                T: std::convert::Into<i32>,
            {
                self.step_end_index = v.map(|x| x.into());
                self
            }

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

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

            /// Sets the value of [travel_mode][crate::model::route_leg::steps_overview::MultiModalSegment::travel_mode].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_maps_routing_v2::model::route_leg::steps_overview::MultiModalSegment;
            /// use google_maps_routing_v2::model::RouteTravelMode;
            /// let x0 = MultiModalSegment::new().set_travel_mode(RouteTravelMode::Drive);
            /// let x1 = MultiModalSegment::new().set_travel_mode(RouteTravelMode::Bicycle);
            /// let x2 = MultiModalSegment::new().set_travel_mode(RouteTravelMode::Walk);
            /// ```
            pub fn set_travel_mode<T: std::convert::Into<crate::model::RouteTravelMode>>(
                mut self,
                v: T,
            ) -> Self {
                self.travel_mode = v.into();
                self
            }
        }

        impl wkt::message::Message for MultiModalSegment {
            fn typename() -> &'static str {
                "type.googleapis.com/google.maps.routing.v2.RouteLeg.StepsOverview.MultiModalSegment"
            }
        }
    }
}

/// Contains a segment of a [`RouteLeg`][google.maps.routing.v2.RouteLeg]. A
/// step corresponds to a single navigation instruction. Route legs are made up
/// of steps.
///
/// [google.maps.routing.v2.RouteLeg]: crate::model::RouteLeg
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RouteLegStep {
    /// The travel distance of this step, in meters. In some circumstances, this
    /// field might not have a value.
    pub distance_meters: i32,

    /// The duration of travel through this step without taking traffic conditions
    /// into consideration. In some circumstances, this field might not have a
    /// value.
    pub static_duration: std::option::Option<wkt::Duration>,

    /// The polyline associated with this step.
    pub polyline: std::option::Option<crate::model::Polyline>,

    /// The start location of this step.
    pub start_location: std::option::Option<crate::model::Location>,

    /// The end location of this step.
    pub end_location: std::option::Option<crate::model::Location>,

    /// Navigation instructions.
    pub navigation_instruction: std::option::Option<crate::model::NavigationInstruction>,

    /// Contains the additional information that the user should be informed
    /// about, such as possible traffic zone restrictions, on a leg step.
    pub travel_advisory: std::option::Option<crate::model::RouteLegStepTravelAdvisory>,

    /// Text representations of properties of the `RouteLegStep`.
    pub localized_values:
        std::option::Option<crate::model::route_leg_step::RouteLegStepLocalizedValues>,

    /// Details pertaining to this step if the travel mode is `TRANSIT`.
    pub transit_details: std::option::Option<crate::model::RouteLegStepTransitDetails>,

    /// The travel mode used for this step.
    pub travel_mode: crate::model::RouteTravelMode,

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

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

    /// Sets the value of [distance_meters][crate::model::RouteLegStep::distance_meters].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteLegStep;
    /// let x = RouteLegStep::new().set_distance_meters(42);
    /// ```
    pub fn set_distance_meters<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.distance_meters = v.into();
        self
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Sets the value of [travel_mode][crate::model::RouteLegStep::travel_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteLegStep;
    /// use google_maps_routing_v2::model::RouteTravelMode;
    /// let x0 = RouteLegStep::new().set_travel_mode(RouteTravelMode::Drive);
    /// let x1 = RouteLegStep::new().set_travel_mode(RouteTravelMode::Bicycle);
    /// let x2 = RouteLegStep::new().set_travel_mode(RouteTravelMode::Walk);
    /// ```
    pub fn set_travel_mode<T: std::convert::Into<crate::model::RouteTravelMode>>(
        mut self,
        v: T,
    ) -> Self {
        self.travel_mode = v.into();
        self
    }
}

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

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

    /// Text representations of certain properties.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct RouteLegStepLocalizedValues {
        /// Travel distance represented in text form.
        pub distance: std::option::Option<google_cloud_type::model::LocalizedText>,

        /// Duration without taking traffic conditions into
        /// consideration, represented in text form.
        pub static_duration: std::option::Option<google_cloud_type::model::LocalizedText>,

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

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

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

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

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

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

    impl wkt::message::Message for RouteLegStepLocalizedValues {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.routing.v2.RouteLegStep.RouteLegStepLocalizedValues"
        }
    }
}

/// Additional information for the `RouteLegStep` related to `TRANSIT` routes.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RouteLegStepTransitDetails {
    /// Information about the arrival and departure stops for the step.
    pub stop_details:
        std::option::Option<crate::model::route_leg_step_transit_details::TransitStopDetails>,

    /// Text representations of properties of the `RouteLegStepTransitDetails`.
    pub localized_values: std::option::Option<
        crate::model::route_leg_step_transit_details::TransitDetailsLocalizedValues,
    >,

    /// Specifies the direction in which to travel on this line as marked on
    /// the vehicle or at the departure stop. The direction is often the terminus
    /// station.
    pub headsign: std::string::String,

    /// Specifies the expected time as a duration between departures from the same
    /// stop at this time. For example, with a headway seconds value of 600, you
    /// would expect a ten minute wait if you should miss your bus.
    pub headway: std::option::Option<wkt::Duration>,

    /// Information about the transit line used in this step.
    pub transit_line: std::option::Option<crate::model::TransitLine>,

    /// The number of stops from the departure to the arrival stop. This count
    /// includes the arrival stop, but excludes the departure stop. For example, if
    /// your route leaves from Stop A, passes through stops B and C, and arrives at
    /// stop D, \<code\>stop_count\</code\> returns 3.
    pub stop_count: i32,

    /// The text that appears in schedules and sign boards to identify a transit
    /// trip to passengers. The text should uniquely identify a trip within a
    /// service day. For example, "538" is the `trip_short_text` of the Amtrak
    /// train that leaves San Jose, CA at 15:10 on weekdays to Sacramento, CA.
    pub trip_short_text: std::string::String,

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

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

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

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

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

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

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

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

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

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

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

    /// Sets the value of [stop_count][crate::model::RouteLegStepTransitDetails::stop_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteLegStepTransitDetails;
    /// let x = RouteLegStepTransitDetails::new().set_stop_count(42);
    /// ```
    pub fn set_stop_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.stop_count = v.into();
        self
    }

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

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

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

    /// Details about the transit stops for the `RouteLegStep`.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct TransitStopDetails {
        /// Information about the arrival stop for the step.
        pub arrival_stop: std::option::Option<crate::model::TransitStop>,

        /// The estimated time of arrival for the step.
        pub arrival_time: std::option::Option<wkt::Timestamp>,

        /// Information about the departure stop for the step.
        pub departure_stop: std::option::Option<crate::model::TransitStop>,

        /// The estimated time of departure for the step.
        pub departure_time: std::option::Option<wkt::Timestamp>,

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

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

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

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

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

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

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

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

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

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

    impl wkt::message::Message for TransitStopDetails {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.routing.v2.RouteLegStepTransitDetails.TransitStopDetails"
        }
    }

    /// Localized descriptions of values for `RouteTransitDetails`.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct TransitDetailsLocalizedValues {
        /// Time in its formatted text representation with a corresponding time zone.
        pub arrival_time: std::option::Option<crate::model::LocalizedTime>,

        /// Time in its formatted text representation with a corresponding time zone.
        pub departure_time: std::option::Option<crate::model::LocalizedTime>,

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

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

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

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

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

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

    impl wkt::message::Message for TransitDetailsLocalizedValues {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.routing.v2.RouteLegStepTransitDetails.TransitDetailsLocalizedValues"
        }
    }
}

/// Encapsulates a set of optional conditions to satisfy when calculating the
/// routes.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RouteModifiers {
    /// 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` [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode].
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub avoid_tolls: bool,

    /// When set to true, avoids highways where reasonable, giving preference to
    /// routes not containing highways. Applies only to the `DRIVE` and
    /// `TWO_WHEELER` [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode].
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub avoid_highways: bool,

    /// When set to true, avoids ferries where reasonable, giving preference to
    /// routes not containing ferries. Applies only to the `DRIVE` and`TWO_WHEELER`
    /// [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode].
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub avoid_ferries: bool,

    /// When set to true, avoids navigating indoors where reasonable, giving
    /// preference to routes not containing indoor navigation. Applies only to the
    /// `WALK` [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode].
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub avoid_indoor: bool,

    /// Specifies the vehicle information.
    pub vehicle_info: std::option::Option<crate::model::VehicleInfo>,

    /// Encapsulates information about toll passes.
    /// If toll passes are provided, the API tries to return the pass price. If
    /// toll passes are not provided, the API treats the toll pass as unknown and
    /// tries to return the cash price.
    /// Applies only to the `DRIVE` and `TWO_WHEELER`
    /// [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode].
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub toll_passes: std::vec::Vec<crate::model::TollPass>,

    /// Optional. When set to true, avoids tunnels where reasonable, giving
    /// preference to routes not containing tunnels. Applies only to the `DRIVE`
    /// and `TWO_WHEELER`
    /// [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode].
    /// [`RoutingPreference`][google.maps.routing.v2.RoutingPreference]
    /// must be set to `TRAFFIC_AWARE_OPTIMAL`.
    /// This field is not supported in ComputeRouteMatrix.
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    /// [google.maps.routing.v2.RoutingPreference]: crate::model::RoutingPreference
    pub avoid_tunnels: bool,

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

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

    /// Sets the value of [avoid_tolls][crate::model::RouteModifiers::avoid_tolls].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteModifiers;
    /// let x = RouteModifiers::new().set_avoid_tolls(true);
    /// ```
    pub fn set_avoid_tolls<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.avoid_tolls = v.into();
        self
    }

    /// Sets the value of [avoid_highways][crate::model::RouteModifiers::avoid_highways].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteModifiers;
    /// let x = RouteModifiers::new().set_avoid_highways(true);
    /// ```
    pub fn set_avoid_highways<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.avoid_highways = v.into();
        self
    }

    /// Sets the value of [avoid_ferries][crate::model::RouteModifiers::avoid_ferries].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteModifiers;
    /// let x = RouteModifiers::new().set_avoid_ferries(true);
    /// ```
    pub fn set_avoid_ferries<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.avoid_ferries = v.into();
        self
    }

    /// Sets the value of [avoid_indoor][crate::model::RouteModifiers::avoid_indoor].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteModifiers;
    /// let x = RouteModifiers::new().set_avoid_indoor(true);
    /// ```
    pub fn set_avoid_indoor<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.avoid_indoor = v.into();
        self
    }

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

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

    /// Sets the value of [toll_passes][crate::model::RouteModifiers::toll_passes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteModifiers;
    /// use google_maps_routing_v2::model::TollPass;
    /// let x = RouteModifiers::new().set_toll_passes([
    ///     TollPass::AuEtollTag,
    ///     TollPass::AuEwayTag,
    ///     TollPass::AuLinkt,
    /// ]);
    /// ```
    pub fn set_toll_passes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::TollPass>,
    {
        use std::iter::Iterator;
        self.toll_passes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [avoid_tunnels][crate::model::RouteModifiers::avoid_tunnels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteModifiers;
    /// let x = RouteModifiers::new().set_avoid_tunnels(true);
    /// ```
    pub fn set_avoid_tunnels<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.avoid_tunnels = v.into();
        self
    }
}

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

/// ComputeRoutes request message.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ComputeRoutesRequest {
    /// Required. Origin waypoint.
    pub origin: std::option::Option<crate::model::Waypoint>,

    /// Required. Destination waypoint.
    pub destination: std::option::Option<crate::model::Waypoint>,

    /// Optional. A set of waypoints along the route (excluding terminal points),
    /// for either stopping at or passing by. Up to 25 intermediate waypoints are
    /// supported.
    pub intermediates: std::vec::Vec<crate::model::Waypoint>,

    /// Optional. Specifies the mode of transportation.
    pub travel_mode: crate::model::RouteTravelMode,

    /// Optional. Specifies how to compute the route. The server
    /// attempts to use the selected routing preference to compute the route. If
    /// the routing preference results in an error or an extra long latency, then
    /// an error is returned. You can specify this option only when the
    /// `travel_mode` is `DRIVE` or `TWO_WHEELER`, otherwise the request fails.
    pub routing_preference: crate::model::RoutingPreference,

    /// Optional. Specifies your preference for the quality of the polyline.
    pub polyline_quality: crate::model::PolylineQuality,

    /// Optional. Specifies the preferred encoding for the polyline.
    pub polyline_encoding: crate::model::PolylineEncoding,

    /// Optional. The departure time. If you don't set this value, then this value
    /// defaults to the time that you made the request.
    /// NOTE: You can only specify a `departure_time` in the past when
    /// [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode] is set to
    /// `TRANSIT`. Transit trips are available for up to 7 days in the past or 100
    /// days in the future.
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub departure_time: std::option::Option<wkt::Timestamp>,

    /// Optional. The arrival time.
    /// NOTE: This field is ignored when requests specify a
    /// [RouteTravelMode][google.maps.routing.v2.RouteTravelMode] other than
    /// `TRANSIT`. You can specify either `departure_time` or `arrival_time`, but
    /// not both. Transit trips are available for up to 7 days in the past or 100
    /// days in the future.
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub arrival_time: std::option::Option<wkt::Timestamp>,

    /// Optional. Specifies whether to calculate alternate routes in addition to
    /// the route. No alternative routes are returned for requests that have
    /// intermediate waypoints.
    pub compute_alternative_routes: bool,

    /// Optional. A set of conditions to satisfy that affect the way routes are
    /// calculated.
    pub route_modifiers: std::option::Option<crate::model::RouteModifiers>,

    /// Optional. The BCP-47 language code, such as "en-US" or "sr-Latn". For more
    /// information, see [Unicode Locale
    /// Identifier](http://www.unicode.org/reports/tr35/#Unicode_locale_identifier).
    /// See [Language
    /// Support](https://developers.google.com/maps/faq#languagesupport)
    /// for the list of supported languages. When you don't provide this value, the
    /// display language is inferred from the location of the route request.
    pub language_code: std::string::String,

    /// Optional. The region code, specified as a ccTLD ("top-level domain")
    /// two-character value. For more information see [Country code top-level
    /// domains](https://en.wikipedia.org/wiki/List_of_Internet_top-level_domains#Country_code_top-level_domains).
    pub region_code: std::string::String,

    /// Optional. Specifies the units of measure for the display fields. These
    /// fields include the `instruction` field in
    /// [`NavigationInstruction`][google.maps.routing.v2.NavigationInstruction].
    /// The units of measure used for the route, leg, step distance, and duration
    /// are not affected by this value. If you don't provide this value, then the
    /// display units are inferred from the location of the first origin.
    ///
    /// [google.maps.routing.v2.NavigationInstruction]: crate::model::NavigationInstruction
    pub units: crate::model::Units,

    /// Optional. If set to true, the service attempts to minimize the overall cost
    /// of the route by re-ordering the specified intermediate waypoints. The
    /// request fails if any of the intermediate waypoints is a `via` waypoint. Use
    /// `ComputeRoutesResponse.routes.optimized_intermediate_waypoint_index` to
    /// find the new ordering.
    /// If `ComputeRoutesResponse.routes.optimized_intermediate_waypoint_index` is
    /// not requested in the `X-Goog-FieldMask` header, the request fails.
    /// If `optimize_waypoint_order` is set to false,
    /// `ComputeRoutesResponse.optimized_intermediate_waypoint_index` will be
    /// empty.
    pub optimize_waypoint_order: bool,

    /// Optional. Specifies what reference routes to calculate as part of the
    /// request in addition to the default route. A reference route is a route with
    /// a different route calculation objective than the default route. For example
    /// a `FUEL_EFFICIENT` reference route calculation takes into account various
    /// parameters that would generate an optimal fuel efficient route. When using
    /// this feature, look for
    /// [`route_labels`][google.maps.routing.v2.Route.route_labels] on the
    /// resulting routes.
    ///
    /// [google.maps.routing.v2.Route.route_labels]: crate::model::Route::route_labels
    pub requested_reference_routes:
        std::vec::Vec<crate::model::compute_routes_request::ReferenceRoute>,

    /// Optional. A list of extra computations which may be used to complete the
    /// request. Note: These extra computations may return extra fields on the
    /// response. These extra fields must also be specified in the field mask to be
    /// returned in the response.
    pub extra_computations: std::vec::Vec<crate::model::compute_routes_request::ExtraComputation>,

    /// Optional. Specifies the assumptions to use when calculating time in
    /// traffic. This setting affects the value returned in the duration field in
    /// the
    /// [`Route`][google.maps.routing.v2.Route] and
    /// [`RouteLeg`][google.maps.routing.v2.RouteLeg] which contains the predicted
    /// time in traffic based on historical averages.
    /// `TrafficModel` is only available for requests that have set
    /// [`RoutingPreference`][google.maps.routing.v2.RoutingPreference] to
    /// `TRAFFIC_AWARE_OPTIMAL` and
    /// [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode] to `DRIVE`.
    /// Defaults to `BEST_GUESS` if traffic is requested and `TrafficModel` is not
    /// specified.
    ///
    /// [google.maps.routing.v2.Route]: crate::model::Route
    /// [google.maps.routing.v2.RouteLeg]: crate::model::RouteLeg
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    /// [google.maps.routing.v2.RoutingPreference]: crate::model::RoutingPreference
    pub traffic_model: crate::model::TrafficModel,

    /// Optional. Specifies preferences that influence the route returned for
    /// `TRANSIT` routes. NOTE: You can only specify a `transit_preferences` when
    /// [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode] is set to
    /// `TRANSIT`.
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub transit_preferences: std::option::Option<crate::model::TransitPreferences>,

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

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

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

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

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

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

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

    /// Sets the value of [travel_mode][crate::model::ComputeRoutesRequest::travel_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRoutesRequest;
    /// use google_maps_routing_v2::model::RouteTravelMode;
    /// let x0 = ComputeRoutesRequest::new().set_travel_mode(RouteTravelMode::Drive);
    /// let x1 = ComputeRoutesRequest::new().set_travel_mode(RouteTravelMode::Bicycle);
    /// let x2 = ComputeRoutesRequest::new().set_travel_mode(RouteTravelMode::Walk);
    /// ```
    pub fn set_travel_mode<T: std::convert::Into<crate::model::RouteTravelMode>>(
        mut self,
        v: T,
    ) -> Self {
        self.travel_mode = v.into();
        self
    }

    /// Sets the value of [routing_preference][crate::model::ComputeRoutesRequest::routing_preference].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRoutesRequest;
    /// use google_maps_routing_v2::model::RoutingPreference;
    /// let x0 = ComputeRoutesRequest::new().set_routing_preference(RoutingPreference::TrafficUnaware);
    /// let x1 = ComputeRoutesRequest::new().set_routing_preference(RoutingPreference::TrafficAware);
    /// let x2 = ComputeRoutesRequest::new().set_routing_preference(RoutingPreference::TrafficAwareOptimal);
    /// ```
    pub fn set_routing_preference<T: std::convert::Into<crate::model::RoutingPreference>>(
        mut self,
        v: T,
    ) -> Self {
        self.routing_preference = v.into();
        self
    }

    /// Sets the value of [polyline_quality][crate::model::ComputeRoutesRequest::polyline_quality].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRoutesRequest;
    /// use google_maps_routing_v2::model::PolylineQuality;
    /// let x0 = ComputeRoutesRequest::new().set_polyline_quality(PolylineQuality::HighQuality);
    /// let x1 = ComputeRoutesRequest::new().set_polyline_quality(PolylineQuality::Overview);
    /// ```
    pub fn set_polyline_quality<T: std::convert::Into<crate::model::PolylineQuality>>(
        mut self,
        v: T,
    ) -> Self {
        self.polyline_quality = v.into();
        self
    }

    /// Sets the value of [polyline_encoding][crate::model::ComputeRoutesRequest::polyline_encoding].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRoutesRequest;
    /// use google_maps_routing_v2::model::PolylineEncoding;
    /// let x0 = ComputeRoutesRequest::new().set_polyline_encoding(PolylineEncoding::EncodedPolyline);
    /// let x1 = ComputeRoutesRequest::new().set_polyline_encoding(PolylineEncoding::GeoJsonLinestring);
    /// ```
    pub fn set_polyline_encoding<T: std::convert::Into<crate::model::PolylineEncoding>>(
        mut self,
        v: T,
    ) -> Self {
        self.polyline_encoding = v.into();
        self
    }

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

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

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

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

    /// Sets the value of [compute_alternative_routes][crate::model::ComputeRoutesRequest::compute_alternative_routes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRoutesRequest;
    /// let x = ComputeRoutesRequest::new().set_compute_alternative_routes(true);
    /// ```
    pub fn set_compute_alternative_routes<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.compute_alternative_routes = v.into();
        self
    }

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

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

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

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

    /// Sets the value of [units][crate::model::ComputeRoutesRequest::units].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRoutesRequest;
    /// use google_maps_routing_v2::model::Units;
    /// let x0 = ComputeRoutesRequest::new().set_units(Units::Metric);
    /// let x1 = ComputeRoutesRequest::new().set_units(Units::Imperial);
    /// ```
    pub fn set_units<T: std::convert::Into<crate::model::Units>>(mut self, v: T) -> Self {
        self.units = v.into();
        self
    }

    /// Sets the value of [optimize_waypoint_order][crate::model::ComputeRoutesRequest::optimize_waypoint_order].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRoutesRequest;
    /// let x = ComputeRoutesRequest::new().set_optimize_waypoint_order(true);
    /// ```
    pub fn set_optimize_waypoint_order<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.optimize_waypoint_order = v.into();
        self
    }

    /// Sets the value of [requested_reference_routes][crate::model::ComputeRoutesRequest::requested_reference_routes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRoutesRequest;
    /// use google_maps_routing_v2::model::compute_routes_request::ReferenceRoute;
    /// let x = ComputeRoutesRequest::new().set_requested_reference_routes([
    ///     ReferenceRoute::FuelEfficient,
    ///     ReferenceRoute::ShorterDistance,
    /// ]);
    /// ```
    pub fn set_requested_reference_routes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::compute_routes_request::ReferenceRoute>,
    {
        use std::iter::Iterator;
        self.requested_reference_routes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [extra_computations][crate::model::ComputeRoutesRequest::extra_computations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRoutesRequest;
    /// use google_maps_routing_v2::model::compute_routes_request::ExtraComputation;
    /// let x = ComputeRoutesRequest::new().set_extra_computations([
    ///     ExtraComputation::Tolls,
    ///     ExtraComputation::FuelConsumption,
    ///     ExtraComputation::TrafficOnPolyline,
    /// ]);
    /// ```
    pub fn set_extra_computations<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::compute_routes_request::ExtraComputation>,
    {
        use std::iter::Iterator;
        self.extra_computations = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [traffic_model][crate::model::ComputeRoutesRequest::traffic_model].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRoutesRequest;
    /// use google_maps_routing_v2::model::TrafficModel;
    /// let x0 = ComputeRoutesRequest::new().set_traffic_model(TrafficModel::BestGuess);
    /// let x1 = ComputeRoutesRequest::new().set_traffic_model(TrafficModel::Pessimistic);
    /// let x2 = ComputeRoutesRequest::new().set_traffic_model(TrafficModel::Optimistic);
    /// ```
    pub fn set_traffic_model<T: std::convert::Into<crate::model::TrafficModel>>(
        mut self,
        v: T,
    ) -> Self {
        self.traffic_model = v.into();
        self
    }

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

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

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

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

    /// A supported reference route on the ComputeRoutesRequest.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum ReferenceRoute {
        /// Not used. Requests containing this value fail.
        Unspecified,
        /// Fuel efficient route.
        FuelEfficient,
        /// Route with shorter travel distance. This is an experimental feature.
        ///
        /// For `DRIVE` requests, this feature prioritizes shorter distance over
        /// driving comfort. For example, it may prefer local roads instead of
        /// highways, take dirt roads, cut through parking lots, etc. This feature
        /// does not return any maneuvers that Google Maps knows to be illegal.
        ///
        /// For `BICYCLE` and `TWO_WHEELER` requests, this feature returns routes
        /// similar to those returned when you don't specify
        /// `requested_reference_routes`.
        ///
        /// This feature is not compatible with any other travel modes, via
        /// intermediate waypoints, or `optimize_waypoint_order`; such requests will
        /// fail. However, you can use it with any `routing_preference`.
        ShorterDistance,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [ReferenceRoute::value] or
        /// [ReferenceRoute::name].
        UnknownValue(reference_route::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for ReferenceRoute {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::FuelEfficient,
                2 => Self::ShorterDistance,
                _ => Self::UnknownValue(reference_route::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for ReferenceRoute {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "REFERENCE_ROUTE_UNSPECIFIED" => Self::Unspecified,
                "FUEL_EFFICIENT" => Self::FuelEfficient,
                "SHORTER_DISTANCE" => Self::ShorterDistance,
                _ => Self::UnknownValue(reference_route::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

    /// Extra computations to perform while completing the request.
    /// Additional values may be added in the future.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum ExtraComputation {
        /// Not used. Requests containing this value will fail.
        Unspecified,
        /// Toll information for the route(s).
        Tolls,
        /// Estimated fuel consumption for the route(s).
        FuelConsumption,
        /// Traffic aware polylines for the route(s).
        TrafficOnPolyline,
        /// [`NavigationInstruction`][google.maps.routing.v2.NavigationInstruction]
        /// presented as a formatted HTML text string. This content
        /// is meant to be read as-is. This content is for display only.
        /// Do not programmatically parse it.
        ///
        /// [google.maps.routing.v2.NavigationInstruction]: crate::model::NavigationInstruction
        HtmlFormattedNavigationInstructions,
        /// Flyover information for the route(s). The
        /// `routes.polyline_details.flyover_info` fieldmask must be specified to
        /// return this information. This data will currently only be populated for
        /// certain metros in India. This feature is experimental, and the
        /// SKU/charge is subject to change.
        FlyoverInfoOnPolyline,
        /// Narrow road information for the route(s). The
        /// `routes.polyline_details.narrow_road_info` fieldmask must be specified
        /// to return this information. This data will currently only be populated
        /// for certain metros in India. This feature is experimental, and the
        /// SKU/charge is subject to change.
        NarrowRoadInfoOnPolyline,
        /// Tunnel information for the route(s). The
        /// `routes.polyline_details.tunnel_info` fieldmask must be specified to
        /// return this information.
        TunnelInfoOnPolyline,
        /// Bridge information for the route(s). The
        /// `routes.polyline_details.bridge_info` fieldmask must be specified to
        /// return this information.
        BridgeInfoOnPolyline,
        /// Skyway information for the route(s). The
        /// `routes.polyline_details.skyway_info` fieldmask must be specified to
        /// return this information.
        SkywayInfoOnPolyline,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [ExtraComputation::value] or
        /// [ExtraComputation::name].
        UnknownValue(extra_computation::UnknownValue),
    }

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

    impl ExtraComputation {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Tolls => std::option::Option::Some(1),
                Self::FuelConsumption => std::option::Option::Some(2),
                Self::TrafficOnPolyline => std::option::Option::Some(3),
                Self::HtmlFormattedNavigationInstructions => std::option::Option::Some(4),
                Self::FlyoverInfoOnPolyline => std::option::Option::Some(7),
                Self::NarrowRoadInfoOnPolyline => std::option::Option::Some(8),
                Self::TunnelInfoOnPolyline => std::option::Option::Some(9),
                Self::BridgeInfoOnPolyline => std::option::Option::Some(10),
                Self::SkywayInfoOnPolyline => std::option::Option::Some(11),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("EXTRA_COMPUTATION_UNSPECIFIED"),
                Self::Tolls => std::option::Option::Some("TOLLS"),
                Self::FuelConsumption => std::option::Option::Some("FUEL_CONSUMPTION"),
                Self::TrafficOnPolyline => std::option::Option::Some("TRAFFIC_ON_POLYLINE"),
                Self::HtmlFormattedNavigationInstructions => {
                    std::option::Option::Some("HTML_FORMATTED_NAVIGATION_INSTRUCTIONS")
                }
                Self::FlyoverInfoOnPolyline => {
                    std::option::Option::Some("FLYOVER_INFO_ON_POLYLINE")
                }
                Self::NarrowRoadInfoOnPolyline => {
                    std::option::Option::Some("NARROW_ROAD_INFO_ON_POLYLINE")
                }
                Self::TunnelInfoOnPolyline => std::option::Option::Some("TUNNEL_INFO_ON_POLYLINE"),
                Self::BridgeInfoOnPolyline => std::option::Option::Some("BRIDGE_INFO_ON_POLYLINE"),
                Self::SkywayInfoOnPolyline => std::option::Option::Some("SKYWAY_INFO_ON_POLYLINE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

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

    impl std::convert::From<i32> for ExtraComputation {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Tolls,
                2 => Self::FuelConsumption,
                3 => Self::TrafficOnPolyline,
                4 => Self::HtmlFormattedNavigationInstructions,
                7 => Self::FlyoverInfoOnPolyline,
                8 => Self::NarrowRoadInfoOnPolyline,
                9 => Self::TunnelInfoOnPolyline,
                10 => Self::BridgeInfoOnPolyline,
                11 => Self::SkywayInfoOnPolyline,
                _ => Self::UnknownValue(extra_computation::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for ExtraComputation {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "EXTRA_COMPUTATION_UNSPECIFIED" => Self::Unspecified,
                "TOLLS" => Self::Tolls,
                "FUEL_CONSUMPTION" => Self::FuelConsumption,
                "TRAFFIC_ON_POLYLINE" => Self::TrafficOnPolyline,
                "HTML_FORMATTED_NAVIGATION_INSTRUCTIONS" => {
                    Self::HtmlFormattedNavigationInstructions
                }
                "FLYOVER_INFO_ON_POLYLINE" => Self::FlyoverInfoOnPolyline,
                "NARROW_ROAD_INFO_ON_POLYLINE" => Self::NarrowRoadInfoOnPolyline,
                "TUNNEL_INFO_ON_POLYLINE" => Self::TunnelInfoOnPolyline,
                "BRIDGE_INFO_ON_POLYLINE" => Self::BridgeInfoOnPolyline,
                "SKYWAY_INFO_ON_POLYLINE" => Self::SkywayInfoOnPolyline,
                _ => Self::UnknownValue(extra_computation::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for ExtraComputation {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Tolls => serializer.serialize_i32(1),
                Self::FuelConsumption => serializer.serialize_i32(2),
                Self::TrafficOnPolyline => serializer.serialize_i32(3),
                Self::HtmlFormattedNavigationInstructions => serializer.serialize_i32(4),
                Self::FlyoverInfoOnPolyline => serializer.serialize_i32(7),
                Self::NarrowRoadInfoOnPolyline => serializer.serialize_i32(8),
                Self::TunnelInfoOnPolyline => serializer.serialize_i32(9),
                Self::BridgeInfoOnPolyline => serializer.serialize_i32(10),
                Self::SkywayInfoOnPolyline => serializer.serialize_i32(11),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// ComputeRoutes the response message.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ComputeRoutesResponse {
    /// Contains an array of computed routes (up to three) when you specify
    /// `compute_alternatives_routes`, and contains just one route when you don't.
    /// When this array contains multiple entries, the first one is the most
    /// recommended route. If the array is empty, then it means no route could be
    /// found.
    pub routes: std::vec::Vec<crate::model::Route>,

    /// In some cases when the server is not able to compute the route results with
    /// all of the input preferences, it may fallback to using a different way of
    /// computation. When fallback mode is used, this field contains detailed info
    /// about the fallback response. Otherwise this field is unset.
    pub fallback_info: std::option::Option<crate::model::FallbackInfo>,

    /// Contains geocoding response info for waypoints specified as addresses.
    pub geocoding_results: std::option::Option<crate::model::GeocodingResults>,

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

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

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

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

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

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

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

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

/// ComputeRouteMatrix request message
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ComputeRouteMatrixRequest {
    /// Required. Array of origins, which determines the rows of the response
    /// matrix. Several size restrictions apply to the cardinality of origins and
    /// destinations:
    ///
    /// * The sum of the number of origins + the number of destinations specified
    ///   as either `place_id` or `address` must be no greater than 50.
    /// * The product of number of origins × number of destinations must be no
    ///   greater than 625 in any case.
    /// * The product of the number of origins × number of destinations must be no
    ///   greater than 100 if routing_preference is set to `TRAFFIC_AWARE_OPTIMAL`.
    /// * The product of the number of origins × number of destinations must be no
    ///   greater than 100 if travel_mode is set to `TRANSIT`.
    pub origins: std::vec::Vec<crate::model::RouteMatrixOrigin>,

    /// Required. Array of destinations, which determines the columns of the
    /// response matrix.
    pub destinations: std::vec::Vec<crate::model::RouteMatrixDestination>,

    /// Optional. Specifies the mode of transportation.
    pub travel_mode: crate::model::RouteTravelMode,

    /// Optional. Specifies how to compute the route. The server attempts to use
    /// the selected routing preference to compute the route. If the routing
    /// preference results in an error or an extra long latency, an error is
    /// returned. You can specify this option only when the `travel_mode` is
    /// `DRIVE` or `TWO_WHEELER`, otherwise the request fails.
    pub routing_preference: crate::model::RoutingPreference,

    /// Optional. The departure time. If you don't set this value, then this value
    /// defaults to the time that you made the request.
    /// NOTE: You can only specify a `departure_time` in the past when
    /// [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode] is set to
    /// `TRANSIT`.
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub departure_time: std::option::Option<wkt::Timestamp>,

    /// Optional. The arrival time.
    /// NOTE: Can only be set when
    /// [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode] is set to
    /// `TRANSIT`. You can specify either `departure_time` or `arrival_time`, but
    /// not both.
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub arrival_time: std::option::Option<wkt::Timestamp>,

    /// Optional. The BCP-47 language code, such as "en-US" or "sr-Latn". For more
    /// information, see [Unicode Locale
    /// Identifier](http://www.unicode.org/reports/tr35/#Unicode_locale_identifier).
    /// See [Language
    /// Support](https://developers.google.com/maps/faq#languagesupport)
    /// for the list of supported languages. When you don't provide this value, the
    /// display language is inferred from the location of the first origin.
    pub language_code: std::string::String,

    /// Optional. The region code, specified as a ccTLD ("top-level domain")
    /// two-character value. For more information see [Country code top-level
    /// domains](https://en.wikipedia.org/wiki/List_of_Internet_top-level_domains#Country_code_top-level_domains).
    pub region_code: std::string::String,

    /// Optional. Specifies the units of measure for the display fields.
    pub units: crate::model::Units,

    /// Optional. A list of extra computations which may be used to complete the
    /// request. Note: These extra computations may return extra fields on the
    /// response. These extra fields must also be specified in the field mask to be
    /// returned in the response.
    pub extra_computations:
        std::vec::Vec<crate::model::compute_route_matrix_request::ExtraComputation>,

    /// Optional. Specifies the assumptions to use when calculating time in
    /// traffic. This setting affects the value returned in the duration field in
    /// the [RouteMatrixElement][google.maps.routing.v2.RouteMatrixElement] which
    /// contains the predicted time in traffic based on historical averages.
    /// `TrafficModel` is only available for requests that have set
    /// [RoutingPreference][google.maps.routing.v2.RoutingPreference] to
    /// `TRAFFIC_AWARE_OPTIMAL` and
    /// [RouteTravelMode][google.maps.routing.v2.RouteTravelMode] to `DRIVE`.
    /// Defaults to `BEST_GUESS` if traffic is requested and `TrafficModel` is not
    /// specified.
    ///
    /// [google.maps.routing.v2.RouteMatrixElement]: crate::model::RouteMatrixElement
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    /// [google.maps.routing.v2.RoutingPreference]: crate::model::RoutingPreference
    pub traffic_model: crate::model::TrafficModel,

    /// Optional. Specifies preferences that influence the route returned for
    /// `TRANSIT` routes. NOTE: You can only specify a `transit_preferences` when
    /// [RouteTravelMode][google.maps.routing.v2.RouteTravelMode] is set to
    /// `TRANSIT`.
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub transit_preferences: std::option::Option<crate::model::TransitPreferences>,

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

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

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

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

    /// Sets the value of [travel_mode][crate::model::ComputeRouteMatrixRequest::travel_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRouteMatrixRequest;
    /// use google_maps_routing_v2::model::RouteTravelMode;
    /// let x0 = ComputeRouteMatrixRequest::new().set_travel_mode(RouteTravelMode::Drive);
    /// let x1 = ComputeRouteMatrixRequest::new().set_travel_mode(RouteTravelMode::Bicycle);
    /// let x2 = ComputeRouteMatrixRequest::new().set_travel_mode(RouteTravelMode::Walk);
    /// ```
    pub fn set_travel_mode<T: std::convert::Into<crate::model::RouteTravelMode>>(
        mut self,
        v: T,
    ) -> Self {
        self.travel_mode = v.into();
        self
    }

    /// Sets the value of [routing_preference][crate::model::ComputeRouteMatrixRequest::routing_preference].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRouteMatrixRequest;
    /// use google_maps_routing_v2::model::RoutingPreference;
    /// let x0 = ComputeRouteMatrixRequest::new().set_routing_preference(RoutingPreference::TrafficUnaware);
    /// let x1 = ComputeRouteMatrixRequest::new().set_routing_preference(RoutingPreference::TrafficAware);
    /// let x2 = ComputeRouteMatrixRequest::new().set_routing_preference(RoutingPreference::TrafficAwareOptimal);
    /// ```
    pub fn set_routing_preference<T: std::convert::Into<crate::model::RoutingPreference>>(
        mut self,
        v: T,
    ) -> Self {
        self.routing_preference = v.into();
        self
    }

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

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

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

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

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

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

    /// Sets the value of [units][crate::model::ComputeRouteMatrixRequest::units].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRouteMatrixRequest;
    /// use google_maps_routing_v2::model::Units;
    /// let x0 = ComputeRouteMatrixRequest::new().set_units(Units::Metric);
    /// let x1 = ComputeRouteMatrixRequest::new().set_units(Units::Imperial);
    /// ```
    pub fn set_units<T: std::convert::Into<crate::model::Units>>(mut self, v: T) -> Self {
        self.units = v.into();
        self
    }

    /// Sets the value of [extra_computations][crate::model::ComputeRouteMatrixRequest::extra_computations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRouteMatrixRequest;
    /// use google_maps_routing_v2::model::compute_route_matrix_request::ExtraComputation;
    /// let x = ComputeRouteMatrixRequest::new().set_extra_computations([
    ///     ExtraComputation::Tolls,
    /// ]);
    /// ```
    pub fn set_extra_computations<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::compute_route_matrix_request::ExtraComputation>,
    {
        use std::iter::Iterator;
        self.extra_computations = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [traffic_model][crate::model::ComputeRouteMatrixRequest::traffic_model].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::ComputeRouteMatrixRequest;
    /// use google_maps_routing_v2::model::TrafficModel;
    /// let x0 = ComputeRouteMatrixRequest::new().set_traffic_model(TrafficModel::BestGuess);
    /// let x1 = ComputeRouteMatrixRequest::new().set_traffic_model(TrafficModel::Pessimistic);
    /// let x2 = ComputeRouteMatrixRequest::new().set_traffic_model(TrafficModel::Optimistic);
    /// ```
    pub fn set_traffic_model<T: std::convert::Into<crate::model::TrafficModel>>(
        mut self,
        v: T,
    ) -> Self {
        self.traffic_model = v.into();
        self
    }

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

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

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

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

    /// Extra computations to perform while completing the request.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum ExtraComputation {
        /// Not used. Requests containing this value will fail.
        Unspecified,
        /// Toll information for the matrix element(s).
        Tolls,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [ExtraComputation::value] or
        /// [ExtraComputation::name].
        UnknownValue(extra_computation::UnknownValue),
    }

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

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

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

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

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

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

    impl std::convert::From<&str> for ExtraComputation {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "EXTRA_COMPUTATION_UNSPECIFIED" => Self::Unspecified,
                "TOLLS" => Self::Tolls,
                _ => Self::UnknownValue(extra_computation::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// A single origin for ComputeRouteMatrixRequest
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RouteMatrixOrigin {
    /// Required. Origin waypoint
    pub waypoint: std::option::Option<crate::model::Waypoint>,

    /// Optional. Modifiers for every route that takes this as the origin
    pub route_modifiers: std::option::Option<crate::model::RouteModifiers>,

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

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

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

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

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

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

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

/// A single destination for ComputeRouteMatrixRequest
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RouteMatrixDestination {
    /// Required. Destination waypoint
    pub waypoint: std::option::Option<crate::model::Waypoint>,

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

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

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

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

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

/// Contains route information computed for an origin/destination pair in the
/// ComputeRouteMatrix API. This proto can be streamed to the client.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RouteMatrixElement {
    /// Zero-based index of the origin in the request.
    pub origin_index: std::option::Option<i32>,

    /// Zero-based index of the destination in the request.
    pub destination_index: std::option::Option<i32>,

    /// Error status code for this element.
    pub status: std::option::Option<google_cloud_rpc::model::Status>,

    /// Indicates whether the route was found or not. Independent of status.
    pub condition: crate::model::RouteMatrixElementCondition,

    /// The travel distance of the route, in meters.
    pub distance_meters: i32,

    /// The length of time needed to navigate the route. If you set the
    /// [routing_preference][google.maps.routing.v2.ComputeRouteMatrixRequest.routing_preference]
    /// to `TRAFFIC_UNAWARE`, then this value is the same as `static_duration`. If
    /// you set the `routing_preference` to either `TRAFFIC_AWARE` or
    /// `TRAFFIC_AWARE_OPTIMAL`, then this value is calculated taking traffic
    /// conditions into account.
    ///
    /// [google.maps.routing.v2.ComputeRouteMatrixRequest.routing_preference]: crate::model::ComputeRouteMatrixRequest::routing_preference
    pub duration: std::option::Option<wkt::Duration>,

    /// The duration of traveling through the route without taking traffic
    /// conditions into consideration.
    pub static_duration: std::option::Option<wkt::Duration>,

    /// Additional information about the route. For example: restriction
    /// information and toll information
    pub travel_advisory: std::option::Option<crate::model::RouteTravelAdvisory>,

    /// In some cases when the server is not able to compute the route with the
    /// given preferences for this particular origin/destination pair, it may
    /// fall back to using a different mode of computation. When fallback mode is
    /// used, this field contains detailed information about the fallback response.
    /// Otherwise this field is unset.
    pub fallback_info: std::option::Option<crate::model::FallbackInfo>,

    /// Text representations of properties of the `RouteMatrixElement`.
    pub localized_values: std::option::Option<crate::model::route_matrix_element::LocalizedValues>,

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

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

    /// Sets the value of [origin_index][crate::model::RouteMatrixElement::origin_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteMatrixElement;
    /// let x = RouteMatrixElement::new().set_origin_index(42);
    /// ```
    pub fn set_origin_index<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.origin_index = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [origin_index][crate::model::RouteMatrixElement::origin_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteMatrixElement;
    /// let x = RouteMatrixElement::new().set_or_clear_origin_index(Some(42));
    /// let x = RouteMatrixElement::new().set_or_clear_origin_index(None::<i32>);
    /// ```
    pub fn set_or_clear_origin_index<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.origin_index = v.map(|x| x.into());
        self
    }

    /// Sets the value of [destination_index][crate::model::RouteMatrixElement::destination_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteMatrixElement;
    /// let x = RouteMatrixElement::new().set_destination_index(42);
    /// ```
    pub fn set_destination_index<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.destination_index = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [destination_index][crate::model::RouteMatrixElement::destination_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteMatrixElement;
    /// let x = RouteMatrixElement::new().set_or_clear_destination_index(Some(42));
    /// let x = RouteMatrixElement::new().set_or_clear_destination_index(None::<i32>);
    /// ```
    pub fn set_or_clear_destination_index<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.destination_index = v.map(|x| x.into());
        self
    }

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

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

    /// Sets the value of [condition][crate::model::RouteMatrixElement::condition].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteMatrixElement;
    /// use google_maps_routing_v2::model::RouteMatrixElementCondition;
    /// let x0 = RouteMatrixElement::new().set_condition(RouteMatrixElementCondition::RouteExists);
    /// let x1 = RouteMatrixElement::new().set_condition(RouteMatrixElementCondition::RouteNotFound);
    /// ```
    pub fn set_condition<T: std::convert::Into<crate::model::RouteMatrixElementCondition>>(
        mut self,
        v: T,
    ) -> Self {
        self.condition = v.into();
        self
    }

    /// Sets the value of [distance_meters][crate::model::RouteMatrixElement::distance_meters].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::RouteMatrixElement;
    /// let x = RouteMatrixElement::new().set_distance_meters(42);
    /// ```
    pub fn set_distance_meters<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.distance_meters = v.into();
        self
    }

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

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

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

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

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

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

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

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

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

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

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

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

    /// Text representations of certain properties.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct LocalizedValues {
        /// Travel distance represented in text form.
        pub distance: std::option::Option<google_cloud_type::model::LocalizedText>,

        /// Duration represented in text form taking traffic conditions into
        /// consideration. Note: If traffic information was not requested, this value
        /// is the same value as static_duration.
        pub duration: std::option::Option<google_cloud_type::model::LocalizedText>,

        /// Duration represented in text form without taking traffic conditions into
        /// consideration.
        pub static_duration: std::option::Option<google_cloud_type::model::LocalizedText>,

        /// Transit fare represented in text form.
        pub transit_fare: std::option::Option<google_cloud_type::model::LocalizedText>,

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

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

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

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

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

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

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

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

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

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

    impl wkt::message::Message for LocalizedValues {
        fn typename() -> &'static str {
            "type.googleapis.com/google.maps.routing.v2.RouteMatrixElement.LocalizedValues"
        }
    }
}

/// Traffic density indicator on a contiguous segment of a polyline or path.
/// Given a path with points P_0, P_1, ... , P_N (zero-based index), the
/// `SpeedReadingInterval` defines an interval and describes its traffic using
/// the following categories.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SpeedReadingInterval {
    /// The starting index of this interval in the polyline.
    pub start_polyline_point_index: std::option::Option<i32>,

    /// The ending index of this interval in the polyline.
    pub end_polyline_point_index: std::option::Option<i32>,

    /// The type of speed in this interval.
    pub speed_type: std::option::Option<crate::model::speed_reading_interval::SpeedType>,

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

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

    /// Sets the value of [start_polyline_point_index][crate::model::SpeedReadingInterval::start_polyline_point_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::SpeedReadingInterval;
    /// let x = SpeedReadingInterval::new().set_start_polyline_point_index(42);
    /// ```
    pub fn set_start_polyline_point_index<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.start_polyline_point_index = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [start_polyline_point_index][crate::model::SpeedReadingInterval::start_polyline_point_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::SpeedReadingInterval;
    /// let x = SpeedReadingInterval::new().set_or_clear_start_polyline_point_index(Some(42));
    /// let x = SpeedReadingInterval::new().set_or_clear_start_polyline_point_index(None::<i32>);
    /// ```
    pub fn set_or_clear_start_polyline_point_index<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.start_polyline_point_index = v.map(|x| x.into());
        self
    }

    /// Sets the value of [end_polyline_point_index][crate::model::SpeedReadingInterval::end_polyline_point_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::SpeedReadingInterval;
    /// let x = SpeedReadingInterval::new().set_end_polyline_point_index(42);
    /// ```
    pub fn set_end_polyline_point_index<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.end_polyline_point_index = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [end_polyline_point_index][crate::model::SpeedReadingInterval::end_polyline_point_index].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::SpeedReadingInterval;
    /// let x = SpeedReadingInterval::new().set_or_clear_end_polyline_point_index(Some(42));
    /// let x = SpeedReadingInterval::new().set_or_clear_end_polyline_point_index(None::<i32>);
    /// ```
    pub fn set_or_clear_end_polyline_point_index<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.end_polyline_point_index = v.map(|x| x.into());
        self
    }

    /// Sets the value of [speed_type][crate::model::SpeedReadingInterval::speed_type].
    ///
    /// Note that all the setters affecting `speed_type` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::SpeedReadingInterval;
    /// use google_maps_routing_v2::model::speed_reading_interval::Speed;
    /// let x0 = SpeedReadingInterval::new().set_speed_type(Some(
    ///     google_maps_routing_v2::model::speed_reading_interval::SpeedType::Speed(Speed::Normal)));
    /// let x1 = SpeedReadingInterval::new().set_speed_type(Some(
    ///     google_maps_routing_v2::model::speed_reading_interval::SpeedType::Speed(Speed::Slow)));
    /// let x2 = SpeedReadingInterval::new().set_speed_type(Some(
    ///     google_maps_routing_v2::model::speed_reading_interval::SpeedType::Speed(Speed::TrafficJam)));
    /// ```
    pub fn set_speed_type<
        T: std::convert::Into<std::option::Option<crate::model::speed_reading_interval::SpeedType>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.speed_type = v.into();
        self
    }

    /// The value of [speed_type][crate::model::SpeedReadingInterval::speed_type]
    /// if it holds a `Speed`, `None` if the field is not set or
    /// holds a different branch.
    pub fn speed(&self) -> std::option::Option<&crate::model::speed_reading_interval::Speed> {
        #[allow(unreachable_patterns)]
        self.speed_type.as_ref().and_then(|v| match v {
            crate::model::speed_reading_interval::SpeedType::Speed(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [speed_type][crate::model::SpeedReadingInterval::speed_type]
    /// to hold a `Speed`.
    ///
    /// Note that all the setters affecting `speed_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::SpeedReadingInterval;
    /// use google_maps_routing_v2::model::speed_reading_interval::Speed;
    /// let x0 = SpeedReadingInterval::new().set_speed(Speed::Normal);
    /// let x1 = SpeedReadingInterval::new().set_speed(Speed::Slow);
    /// let x2 = SpeedReadingInterval::new().set_speed(Speed::TrafficJam);
    /// assert!(x0.speed().is_some());
    /// assert!(x1.speed().is_some());
    /// assert!(x2.speed().is_some());
    /// ```
    pub fn set_speed<T: std::convert::Into<crate::model::speed_reading_interval::Speed>>(
        mut self,
        v: T,
    ) -> Self {
        self.speed_type = std::option::Option::Some(
            crate::model::speed_reading_interval::SpeedType::Speed(v.into()),
        );
        self
    }
}

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

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

    /// The classification of polyline speed based on traffic data.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Speed {
        /// Default value. This value is unused.
        Unspecified,
        /// Normal speed, no traffic delays.
        Normal,
        /// Slowdown detected, medium amount of traffic.
        Slow,
        /// Traffic delays.
        TrafficJam,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Speed::value] or
        /// [Speed::name].
        UnknownValue(speed::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for Speed {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Normal,
                2 => Self::Slow,
                3 => Self::TrafficJam,
                _ => Self::UnknownValue(speed::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Speed {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "SPEED_UNSPECIFIED" => Self::Unspecified,
                "NORMAL" => Self::Normal,
                "SLOW" => Self::Slow,
                "TRAFFIC_JAM" => Self::TrafficJam,
                _ => Self::UnknownValue(speed::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

    /// The type of speed in this interval.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum SpeedType {
        /// Traffic speed in this interval.
        Speed(crate::model::speed_reading_interval::Speed),
    }
}

/// Encapsulates toll information on a [`Route`][google.maps.routing.v2.Route] or
/// on a [`RouteLeg`][google.maps.routing.v2.RouteLeg].
///
/// [google.maps.routing.v2.Route]: crate::model::Route
/// [google.maps.routing.v2.RouteLeg]: crate::model::RouteLeg
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TollInfo {
    /// The monetary amount of tolls for the corresponding
    /// [`Route`][google.maps.routing.v2.Route] or
    /// [`RouteLeg`][google.maps.routing.v2.RouteLeg]. This list contains a money
    /// amount for each currency that is expected to be charged by the toll
    /// stations. Typically this list will contain only one item for routes with
    /// tolls in one currency. For international trips, this list may contain
    /// multiple items to reflect tolls in different currencies.
    ///
    /// [google.maps.routing.v2.Route]: crate::model::Route
    /// [google.maps.routing.v2.RouteLeg]: crate::model::RouteLeg
    pub estimated_price: std::vec::Vec<google_cloud_type::model::Money>,

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

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

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

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

/// A transit agency that operates a transit line.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TransitAgency {
    /// The name of this transit agency.
    pub name: std::string::String,

    /// The transit agency's locale-specific formatted phone number.
    pub phone_number: std::string::String,

    /// The transit agency's URI.
    pub uri: std::string::String,

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

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

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

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

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

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

/// Contains information about the transit line used in this step.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TransitLine {
    /// The transit agency (or agencies) that operates this transit line.
    pub agencies: std::vec::Vec<crate::model::TransitAgency>,

    /// The full name of this transit line, For example, "8 Avenue Local".
    pub name: std::string::String,

    /// the URI for this transit line as provided by the transit agency.
    pub uri: std::string::String,

    /// The color commonly used in signage for this line. Represented in
    /// hexadecimal.
    pub color: std::string::String,

    /// The URI for the icon associated with this line.
    pub icon_uri: std::string::String,

    /// The short name of this transit line. This name will normally be a line
    /// number, such as "M7" or "355".
    pub name_short: std::string::String,

    /// The color commonly used in text on signage for this line. Represented in
    /// hexadecimal.
    pub text_color: std::string::String,

    /// The type of vehicle that operates on this transit line.
    pub vehicle: std::option::Option<crate::model::TransitVehicle>,

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

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

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

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

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

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

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

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

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

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

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

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

/// Information about a transit stop.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TransitStop {
    /// The name of the transit stop.
    pub name: std::string::String,

    /// The location of the stop expressed in latitude/longitude coordinates.
    pub location: std::option::Option<crate::model::Location>,

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

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

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

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

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

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

/// Information about a vehicle used in transit routes.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TransitVehicle {
    /// The name of this vehicle, capitalized.
    pub name: std::option::Option<google_cloud_type::model::LocalizedText>,

    /// The type of vehicle used.
    pub r#type: crate::model::transit_vehicle::TransitVehicleType,

    /// The URI for an icon associated with this vehicle type.
    pub icon_uri: std::string::String,

    /// The URI for the icon associated with this vehicle type, based on the local
    /// transport signage.
    pub local_icon_uri: std::string::String,

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

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

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

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

    /// Sets the value of [r#type][crate::model::TransitVehicle::type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::TransitVehicle;
    /// use google_maps_routing_v2::model::transit_vehicle::TransitVehicleType;
    /// let x0 = TransitVehicle::new().set_type(TransitVehicleType::Bus);
    /// let x1 = TransitVehicle::new().set_type(TransitVehicleType::CableCar);
    /// let x2 = TransitVehicle::new().set_type(TransitVehicleType::CommuterTrain);
    /// ```
    pub fn set_type<T: std::convert::Into<crate::model::transit_vehicle::TransitVehicleType>>(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = v.into();
        self
    }

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

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

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

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

    /// The type of vehicles for transit routes.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum TransitVehicleType {
        /// Unused.
        Unspecified,
        /// Bus.
        Bus,
        /// A vehicle that operates on a cable, usually on the ground. Aerial cable
        /// cars may be of the type `GONDOLA_LIFT`.
        CableCar,
        /// Commuter rail.
        CommuterTrain,
        /// Ferry.
        Ferry,
        /// A vehicle that is pulled up a steep incline by a cable. A Funicular
        /// typically consists of two cars, with each car acting as a counterweight
        /// for the other.
        Funicular,
        /// An aerial cable car.
        GondolaLift,
        /// Heavy rail.
        HeavyRail,
        /// High speed train.
        HighSpeedTrain,
        /// Intercity bus.
        IntercityBus,
        /// Long distance train.
        LongDistanceTrain,
        /// Light rail transit.
        MetroRail,
        /// Monorail.
        Monorail,
        /// All other vehicles.
        Other,
        /// Rail.
        Rail,
        /// Share taxi is a kind of bus with the ability to drop off and pick up
        /// passengers anywhere on its route.
        ShareTaxi,
        /// Underground light rail.
        Subway,
        /// Above ground light rail.
        Tram,
        /// Trolleybus.
        Trolleybus,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [TransitVehicleType::value] or
        /// [TransitVehicleType::name].
        UnknownValue(transit_vehicle_type::UnknownValue),
    }

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

    impl TransitVehicleType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Bus => std::option::Option::Some(1),
                Self::CableCar => std::option::Option::Some(2),
                Self::CommuterTrain => std::option::Option::Some(3),
                Self::Ferry => std::option::Option::Some(4),
                Self::Funicular => std::option::Option::Some(5),
                Self::GondolaLift => std::option::Option::Some(6),
                Self::HeavyRail => std::option::Option::Some(7),
                Self::HighSpeedTrain => std::option::Option::Some(8),
                Self::IntercityBus => std::option::Option::Some(9),
                Self::LongDistanceTrain => std::option::Option::Some(10),
                Self::MetroRail => std::option::Option::Some(11),
                Self::Monorail => std::option::Option::Some(12),
                Self::Other => std::option::Option::Some(13),
                Self::Rail => std::option::Option::Some(14),
                Self::ShareTaxi => std::option::Option::Some(15),
                Self::Subway => std::option::Option::Some(16),
                Self::Tram => std::option::Option::Some(17),
                Self::Trolleybus => std::option::Option::Some(18),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("TRANSIT_VEHICLE_TYPE_UNSPECIFIED"),
                Self::Bus => std::option::Option::Some("BUS"),
                Self::CableCar => std::option::Option::Some("CABLE_CAR"),
                Self::CommuterTrain => std::option::Option::Some("COMMUTER_TRAIN"),
                Self::Ferry => std::option::Option::Some("FERRY"),
                Self::Funicular => std::option::Option::Some("FUNICULAR"),
                Self::GondolaLift => std::option::Option::Some("GONDOLA_LIFT"),
                Self::HeavyRail => std::option::Option::Some("HEAVY_RAIL"),
                Self::HighSpeedTrain => std::option::Option::Some("HIGH_SPEED_TRAIN"),
                Self::IntercityBus => std::option::Option::Some("INTERCITY_BUS"),
                Self::LongDistanceTrain => std::option::Option::Some("LONG_DISTANCE_TRAIN"),
                Self::MetroRail => std::option::Option::Some("METRO_RAIL"),
                Self::Monorail => std::option::Option::Some("MONORAIL"),
                Self::Other => std::option::Option::Some("OTHER"),
                Self::Rail => std::option::Option::Some("RAIL"),
                Self::ShareTaxi => std::option::Option::Some("SHARE_TAXI"),
                Self::Subway => std::option::Option::Some("SUBWAY"),
                Self::Tram => std::option::Option::Some("TRAM"),
                Self::Trolleybus => std::option::Option::Some("TROLLEYBUS"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

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

    impl std::convert::From<i32> for TransitVehicleType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Bus,
                2 => Self::CableCar,
                3 => Self::CommuterTrain,
                4 => Self::Ferry,
                5 => Self::Funicular,
                6 => Self::GondolaLift,
                7 => Self::HeavyRail,
                8 => Self::HighSpeedTrain,
                9 => Self::IntercityBus,
                10 => Self::LongDistanceTrain,
                11 => Self::MetroRail,
                12 => Self::Monorail,
                13 => Self::Other,
                14 => Self::Rail,
                15 => Self::ShareTaxi,
                16 => Self::Subway,
                17 => Self::Tram,
                18 => Self::Trolleybus,
                _ => Self::UnknownValue(transit_vehicle_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for TransitVehicleType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TRANSIT_VEHICLE_TYPE_UNSPECIFIED" => Self::Unspecified,
                "BUS" => Self::Bus,
                "CABLE_CAR" => Self::CableCar,
                "COMMUTER_TRAIN" => Self::CommuterTrain,
                "FERRY" => Self::Ferry,
                "FUNICULAR" => Self::Funicular,
                "GONDOLA_LIFT" => Self::GondolaLift,
                "HEAVY_RAIL" => Self::HeavyRail,
                "HIGH_SPEED_TRAIN" => Self::HighSpeedTrain,
                "INTERCITY_BUS" => Self::IntercityBus,
                "LONG_DISTANCE_TRAIN" => Self::LongDistanceTrain,
                "METRO_RAIL" => Self::MetroRail,
                "MONORAIL" => Self::Monorail,
                "OTHER" => Self::Other,
                "RAIL" => Self::Rail,
                "SHARE_TAXI" => Self::ShareTaxi,
                "SUBWAY" => Self::Subway,
                "TRAM" => Self::Tram,
                "TROLLEYBUS" => Self::Trolleybus,
                _ => Self::UnknownValue(transit_vehicle_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for TransitVehicleType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Bus => serializer.serialize_i32(1),
                Self::CableCar => serializer.serialize_i32(2),
                Self::CommuterTrain => serializer.serialize_i32(3),
                Self::Ferry => serializer.serialize_i32(4),
                Self::Funicular => serializer.serialize_i32(5),
                Self::GondolaLift => serializer.serialize_i32(6),
                Self::HeavyRail => serializer.serialize_i32(7),
                Self::HighSpeedTrain => serializer.serialize_i32(8),
                Self::IntercityBus => serializer.serialize_i32(9),
                Self::LongDistanceTrain => serializer.serialize_i32(10),
                Self::MetroRail => serializer.serialize_i32(11),
                Self::Monorail => serializer.serialize_i32(12),
                Self::Other => serializer.serialize_i32(13),
                Self::Rail => serializer.serialize_i32(14),
                Self::ShareTaxi => serializer.serialize_i32(15),
                Self::Subway => serializer.serialize_i32(16),
                Self::Tram => serializer.serialize_i32(17),
                Self::Trolleybus => serializer.serialize_i32(18),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// Preferences for `TRANSIT` based routes that influence the route that is
/// returned.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TransitPreferences {
    /// A set of travel modes to use when getting a `TRANSIT` route. Defaults to
    /// all supported modes of travel.
    pub allowed_travel_modes: std::vec::Vec<crate::model::transit_preferences::TransitTravelMode>,

    /// A routing preference that, when specified, influences the `TRANSIT` route
    /// returned.
    pub routing_preference: crate::model::transit_preferences::TransitRoutingPreference,

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

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

    /// Sets the value of [allowed_travel_modes][crate::model::TransitPreferences::allowed_travel_modes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::TransitPreferences;
    /// use google_maps_routing_v2::model::transit_preferences::TransitTravelMode;
    /// let x = TransitPreferences::new().set_allowed_travel_modes([
    ///     TransitTravelMode::Bus,
    ///     TransitTravelMode::Subway,
    ///     TransitTravelMode::Train,
    /// ]);
    /// ```
    pub fn set_allowed_travel_modes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::transit_preferences::TransitTravelMode>,
    {
        use std::iter::Iterator;
        self.allowed_travel_modes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [routing_preference][crate::model::TransitPreferences::routing_preference].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::TransitPreferences;
    /// use google_maps_routing_v2::model::transit_preferences::TransitRoutingPreference;
    /// let x0 = TransitPreferences::new().set_routing_preference(TransitRoutingPreference::LessWalking);
    /// let x1 = TransitPreferences::new().set_routing_preference(TransitRoutingPreference::FewerTransfers);
    /// ```
    pub fn set_routing_preference<
        T: std::convert::Into<crate::model::transit_preferences::TransitRoutingPreference>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.routing_preference = v.into();
        self
    }
}

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

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

    /// A set of values used to specify the mode of transit.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum TransitTravelMode {
        /// No transit travel mode specified.
        Unspecified,
        /// Travel by bus.
        Bus,
        /// Travel by subway.
        Subway,
        /// Travel by train.
        Train,
        /// Travel by light rail or tram.
        LightRail,
        /// Travel by rail. This is equivalent to a combination of `SUBWAY`, `TRAIN`,
        /// and `LIGHT_RAIL`.
        Rail,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [TransitTravelMode::value] or
        /// [TransitTravelMode::name].
        UnknownValue(transit_travel_mode::UnknownValue),
    }

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

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

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("TRANSIT_TRAVEL_MODE_UNSPECIFIED"),
                Self::Bus => std::option::Option::Some("BUS"),
                Self::Subway => std::option::Option::Some("SUBWAY"),
                Self::Train => std::option::Option::Some("TRAIN"),
                Self::LightRail => std::option::Option::Some("LIGHT_RAIL"),
                Self::Rail => std::option::Option::Some("RAIL"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

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

    impl std::convert::From<i32> for TransitTravelMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Bus,
                2 => Self::Subway,
                3 => Self::Train,
                4 => Self::LightRail,
                5 => Self::Rail,
                _ => Self::UnknownValue(transit_travel_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for TransitTravelMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TRANSIT_TRAVEL_MODE_UNSPECIFIED" => Self::Unspecified,
                "BUS" => Self::Bus,
                "SUBWAY" => Self::Subway,
                "TRAIN" => Self::Train,
                "LIGHT_RAIL" => Self::LightRail,
                "RAIL" => Self::Rail,
                _ => Self::UnknownValue(transit_travel_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for TransitTravelMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Bus => serializer.serialize_i32(1),
                Self::Subway => serializer.serialize_i32(2),
                Self::Train => serializer.serialize_i32(3),
                Self::LightRail => serializer.serialize_i32(4),
                Self::Rail => serializer.serialize_i32(5),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

    /// Specifies routing preferences for transit routes.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum TransitRoutingPreference {
        /// No preference specified.
        Unspecified,
        /// Indicates that the calculated route should prefer limited amounts of
        /// walking.
        LessWalking,
        /// Indicates that the calculated route should prefer a limited number of
        /// transfers.
        FewerTransfers,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [TransitRoutingPreference::value] or
        /// [TransitRoutingPreference::name].
        UnknownValue(transit_routing_preference::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for TransitRoutingPreference {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::LessWalking,
                2 => Self::FewerTransfers,
                _ => Self::UnknownValue(transit_routing_preference::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for TransitRoutingPreference {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TRANSIT_ROUTING_PREFERENCE_UNSPECIFIED" => Self::Unspecified,
                "LESS_WALKING" => Self::LessWalking,
                "FEWER_TRANSFERS" => Self::FewerTransfers,
                _ => Self::UnknownValue(transit_routing_preference::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// Contains the vehicle information, such as the vehicle emission type.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct VehicleInfo {
    /// Describes the vehicle's emission type.
    /// Applies only to the `DRIVE`
    /// [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode].
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub emission_type: crate::model::VehicleEmissionType,

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

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

    /// Sets the value of [emission_type][crate::model::VehicleInfo::emission_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::VehicleInfo;
    /// use google_maps_routing_v2::model::VehicleEmissionType;
    /// let x0 = VehicleInfo::new().set_emission_type(VehicleEmissionType::Gasoline);
    /// let x1 = VehicleInfo::new().set_emission_type(VehicleEmissionType::Electric);
    /// let x2 = VehicleInfo::new().set_emission_type(VehicleEmissionType::Hybrid);
    /// ```
    pub fn set_emission_type<T: std::convert::Into<crate::model::VehicleEmissionType>>(
        mut self,
        v: T,
    ) -> Self {
        self.emission_type = v.into();
        self
    }
}

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

/// Encapsulates a waypoint. Waypoints mark both the beginning and end of a
/// route, and include intermediate stops along the route.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Waypoint {
    /// Marks this waypoint as a milestone rather a stopping point. For
    /// each non-via waypoint in the request, the response appends an entry to the
    /// [`legs`][google.maps.routing.v2.Route.legs]
    /// array to provide the details for stopovers on that leg of the trip. Set
    /// this value to true when you want the route to pass through this waypoint
    /// without stopping over. Via waypoints don't cause an entry to be added to
    /// the `legs` array, but they do route the journey through the waypoint. You
    /// can only set this value on waypoints that are intermediates. The request
    /// fails if you set this field on terminal waypoints. If
    /// `ComputeRoutesRequest.optimize_waypoint_order` is set to true then this
    /// field cannot be set to true; otherwise, the request fails.
    ///
    /// [google.maps.routing.v2.Route.legs]: crate::model::Route::legs
    pub via: bool,

    /// Indicates that the waypoint is meant for vehicles to stop at, where the
    /// intention is to either pickup or drop-off. When you set this value, the
    /// calculated route won't include non-`via` waypoints on roads that are
    /// unsuitable for pickup and drop-off. This option works only for `DRIVE` and
    /// `TWO_WHEELER` travel modes, and when the `location_type` is
    /// [`Location`][google.maps.routing.v2.Location].
    ///
    /// [google.maps.routing.v2.Location]: crate::model::Location
    pub vehicle_stopover: bool,

    /// Indicates that the location of this waypoint is meant to have a preference
    /// for the vehicle to stop at a particular side of road. When you set this
    /// value, the route will pass through the location so that the vehicle can
    /// stop at the side of road that the location is biased towards from the
    /// center of the road. This option works only for `DRIVE` and `TWO_WHEELER`
    /// [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode].
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    pub side_of_road: bool,

    /// Different ways to represent a location.
    pub location_type: std::option::Option<crate::model::waypoint::LocationType>,

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

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

    /// Sets the value of [via][crate::model::Waypoint::via].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::Waypoint;
    /// let x = Waypoint::new().set_via(true);
    /// ```
    pub fn set_via<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.via = v.into();
        self
    }

    /// Sets the value of [vehicle_stopover][crate::model::Waypoint::vehicle_stopover].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::Waypoint;
    /// let x = Waypoint::new().set_vehicle_stopover(true);
    /// ```
    pub fn set_vehicle_stopover<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.vehicle_stopover = v.into();
        self
    }

    /// Sets the value of [side_of_road][crate::model::Waypoint::side_of_road].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::Waypoint;
    /// let x = Waypoint::new().set_side_of_road(true);
    /// ```
    pub fn set_side_of_road<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.side_of_road = v.into();
        self
    }

    /// Sets the value of [location_type][crate::model::Waypoint::location_type].
    ///
    /// Note that all the setters affecting `location_type` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::Waypoint;
    /// use google_maps_routing_v2::model::waypoint::LocationType;
    /// let x = Waypoint::new().set_location_type(Some(LocationType::PlaceId("example".to_string())));
    /// ```
    pub fn set_location_type<
        T: std::convert::Into<std::option::Option<crate::model::waypoint::LocationType>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.location_type = v.into();
        self
    }

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

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

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

    /// Sets the value of [location_type][crate::model::Waypoint::location_type]
    /// to hold a `PlaceId`.
    ///
    /// Note that all the setters affecting `location_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::Waypoint;
    /// let x = Waypoint::new().set_place_id("example");
    /// assert!(x.place_id().is_some());
    /// assert!(x.location().is_none());
    /// assert!(x.address().is_none());
    /// assert!(x.navigation_point_token().is_none());
    /// ```
    pub fn set_place_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.location_type =
            std::option::Option::Some(crate::model::waypoint::LocationType::PlaceId(v.into()));
        self
    }

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

    /// Sets the value of [location_type][crate::model::Waypoint::location_type]
    /// to hold a `Address`.
    ///
    /// Note that all the setters affecting `location_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::Waypoint;
    /// let x = Waypoint::new().set_address("example");
    /// assert!(x.address().is_some());
    /// assert!(x.location().is_none());
    /// assert!(x.place_id().is_none());
    /// assert!(x.navigation_point_token().is_none());
    /// ```
    pub fn set_address<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.location_type =
            std::option::Option::Some(crate::model::waypoint::LocationType::Address(v.into()));
        self
    }

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

    /// Sets the value of [location_type][crate::model::Waypoint::location_type]
    /// to hold a `NavigationPointToken`.
    ///
    /// Note that all the setters affecting `location_type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_maps_routing_v2::model::Waypoint;
    /// let x = Waypoint::new().set_navigation_point_token("example");
    /// assert!(x.navigation_point_token().is_some());
    /// assert!(x.location().is_none());
    /// assert!(x.place_id().is_none());
    /// assert!(x.address().is_none());
    /// ```
    pub fn set_navigation_point_token<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.location_type = std::option::Option::Some(
            crate::model::waypoint::LocationType::NavigationPointToken(v.into()),
        );
        self
    }
}

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

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

    /// Different ways to represent a location.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum LocationType {
        /// A point specified using geographic coordinates, including an optional
        /// heading.
        Location(std::boxed::Box<crate::model::Location>),
        /// The POI Place ID associated with the waypoint.
        PlaceId(std::string::String),
        /// Human readable address or a plus code.
        /// See <https://plus.codes> for details.
        Address(std::string::String),
        /// A token that identifies a
        /// [`NavigationPoint`](/maps/documentation/geocoding/reference/rest/v4alpha/geocode.destinations/searchDestinations#navigationpoint),
        /// obtained from the `SearchDestinations` method of the Geocoding API.
        NavigationPointToken(std::string::String),
    }
}

/// Reasons for using fallback response.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum FallbackReason {
    /// No fallback reason specified.
    Unspecified,
    /// A server error happened while calculating routes with your preferred
    /// routing mode, but we were able to return a result calculated by an
    /// alternative mode.
    ServerError,
    /// We were not able to finish the calculation with your preferred routing mode
    /// on time, but we were able to return a result calculated by an alternative
    /// mode.
    LatencyExceeded,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [FallbackReason::value] or
    /// [FallbackReason::name].
    UnknownValue(fallback_reason::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<i32> for FallbackReason {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::ServerError,
            2 => Self::LatencyExceeded,
            _ => Self::UnknownValue(fallback_reason::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for FallbackReason {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "FALLBACK_REASON_UNSPECIFIED" => Self::Unspecified,
            "SERVER_ERROR" => Self::ServerError,
            "LATENCY_EXCEEDED" => Self::LatencyExceeded,
            _ => Self::UnknownValue(fallback_reason::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

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

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

/// Actual routing mode used for returned fallback response.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum FallbackRoutingMode {
    /// Not used.
    Unspecified,
    /// Indicates the `TRAFFIC_UNAWARE`
    /// [`RoutingPreference`][google.maps.routing.v2.RoutingPreference] was used to
    /// compute the response.
    ///
    /// [google.maps.routing.v2.RoutingPreference]: crate::model::RoutingPreference
    FallbackTrafficUnaware,
    /// Indicates the `TRAFFIC_AWARE`
    /// [`RoutingPreference`][google.maps.routing.v2.RoutingPreference] was used to
    /// compute the response.
    ///
    /// [google.maps.routing.v2.RoutingPreference]: crate::model::RoutingPreference
    FallbackTrafficAware,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [FallbackRoutingMode::value] or
    /// [FallbackRoutingMode::name].
    UnknownValue(fallback_routing_mode::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<i32> for FallbackRoutingMode {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::FallbackTrafficUnaware,
            2 => Self::FallbackTrafficAware,
            _ => Self::UnknownValue(fallback_routing_mode::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for FallbackRoutingMode {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "FALLBACK_ROUTING_MODE_UNSPECIFIED" => Self::Unspecified,
            "FALLBACK_TRAFFIC_UNAWARE" => Self::FallbackTrafficUnaware,
            "FALLBACK_TRAFFIC_AWARE" => Self::FallbackTrafficAware,
            _ => Self::UnknownValue(fallback_routing_mode::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

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

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

/// A set of values that specify the navigation action to take for the current
/// step (for example, turn left, merge, or straight).
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum Maneuver {
    /// Not used.
    Unspecified,
    /// Turn slightly to the left.
    TurnSlightLeft,
    /// Turn sharply to the left.
    TurnSharpLeft,
    /// Make a left u-turn.
    UturnLeft,
    /// Turn left.
    TurnLeft,
    /// Turn slightly to the right.
    TurnSlightRight,
    /// Turn sharply to the right.
    TurnSharpRight,
    /// Make a right u-turn.
    UturnRight,
    /// Turn right.
    TurnRight,
    /// Go straight.
    Straight,
    /// Take the left ramp.
    RampLeft,
    /// Take the right ramp.
    RampRight,
    /// Merge into traffic.
    Merge,
    /// Take the left fork.
    ForkLeft,
    /// Take the right fork.
    ForkRight,
    /// Take the ferry.
    Ferry,
    /// Take the train leading onto the ferry.
    FerryTrain,
    /// Turn left at the roundabout.
    RoundaboutLeft,
    /// Turn right at the roundabout.
    RoundaboutRight,
    /// Initial maneuver.
    Depart,
    /// Used to indicate a street name change.
    NameChange,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [Maneuver::value] or
    /// [Maneuver::name].
    UnknownValue(maneuver::UnknownValue),
}

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

impl Maneuver {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::TurnSlightLeft => std::option::Option::Some(1),
            Self::TurnSharpLeft => std::option::Option::Some(2),
            Self::UturnLeft => std::option::Option::Some(3),
            Self::TurnLeft => std::option::Option::Some(4),
            Self::TurnSlightRight => std::option::Option::Some(5),
            Self::TurnSharpRight => std::option::Option::Some(6),
            Self::UturnRight => std::option::Option::Some(7),
            Self::TurnRight => std::option::Option::Some(8),
            Self::Straight => std::option::Option::Some(9),
            Self::RampLeft => std::option::Option::Some(10),
            Self::RampRight => std::option::Option::Some(11),
            Self::Merge => std::option::Option::Some(12),
            Self::ForkLeft => std::option::Option::Some(13),
            Self::ForkRight => std::option::Option::Some(14),
            Self::Ferry => std::option::Option::Some(15),
            Self::FerryTrain => std::option::Option::Some(16),
            Self::RoundaboutLeft => std::option::Option::Some(17),
            Self::RoundaboutRight => std::option::Option::Some(18),
            Self::Depart => std::option::Option::Some(19),
            Self::NameChange => std::option::Option::Some(20),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("MANEUVER_UNSPECIFIED"),
            Self::TurnSlightLeft => std::option::Option::Some("TURN_SLIGHT_LEFT"),
            Self::TurnSharpLeft => std::option::Option::Some("TURN_SHARP_LEFT"),
            Self::UturnLeft => std::option::Option::Some("UTURN_LEFT"),
            Self::TurnLeft => std::option::Option::Some("TURN_LEFT"),
            Self::TurnSlightRight => std::option::Option::Some("TURN_SLIGHT_RIGHT"),
            Self::TurnSharpRight => std::option::Option::Some("TURN_SHARP_RIGHT"),
            Self::UturnRight => std::option::Option::Some("UTURN_RIGHT"),
            Self::TurnRight => std::option::Option::Some("TURN_RIGHT"),
            Self::Straight => std::option::Option::Some("STRAIGHT"),
            Self::RampLeft => std::option::Option::Some("RAMP_LEFT"),
            Self::RampRight => std::option::Option::Some("RAMP_RIGHT"),
            Self::Merge => std::option::Option::Some("MERGE"),
            Self::ForkLeft => std::option::Option::Some("FORK_LEFT"),
            Self::ForkRight => std::option::Option::Some("FORK_RIGHT"),
            Self::Ferry => std::option::Option::Some("FERRY"),
            Self::FerryTrain => std::option::Option::Some("FERRY_TRAIN"),
            Self::RoundaboutLeft => std::option::Option::Some("ROUNDABOUT_LEFT"),
            Self::RoundaboutRight => std::option::Option::Some("ROUNDABOUT_RIGHT"),
            Self::Depart => std::option::Option::Some("DEPART"),
            Self::NameChange => std::option::Option::Some("NAME_CHANGE"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

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

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

impl std::convert::From<i32> for Maneuver {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::TurnSlightLeft,
            2 => Self::TurnSharpLeft,
            3 => Self::UturnLeft,
            4 => Self::TurnLeft,
            5 => Self::TurnSlightRight,
            6 => Self::TurnSharpRight,
            7 => Self::UturnRight,
            8 => Self::TurnRight,
            9 => Self::Straight,
            10 => Self::RampLeft,
            11 => Self::RampRight,
            12 => Self::Merge,
            13 => Self::ForkLeft,
            14 => Self::ForkRight,
            15 => Self::Ferry,
            16 => Self::FerryTrain,
            17 => Self::RoundaboutLeft,
            18 => Self::RoundaboutRight,
            19 => Self::Depart,
            20 => Self::NameChange,
            _ => Self::UnknownValue(maneuver::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for Maneuver {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "MANEUVER_UNSPECIFIED" => Self::Unspecified,
            "TURN_SLIGHT_LEFT" => Self::TurnSlightLeft,
            "TURN_SHARP_LEFT" => Self::TurnSharpLeft,
            "UTURN_LEFT" => Self::UturnLeft,
            "TURN_LEFT" => Self::TurnLeft,
            "TURN_SLIGHT_RIGHT" => Self::TurnSlightRight,
            "TURN_SHARP_RIGHT" => Self::TurnSharpRight,
            "UTURN_RIGHT" => Self::UturnRight,
            "TURN_RIGHT" => Self::TurnRight,
            "STRAIGHT" => Self::Straight,
            "RAMP_LEFT" => Self::RampLeft,
            "RAMP_RIGHT" => Self::RampRight,
            "MERGE" => Self::Merge,
            "FORK_LEFT" => Self::ForkLeft,
            "FORK_RIGHT" => Self::ForkRight,
            "FERRY" => Self::Ferry,
            "FERRY_TRAIN" => Self::FerryTrain,
            "ROUNDABOUT_LEFT" => Self::RoundaboutLeft,
            "ROUNDABOUT_RIGHT" => Self::RoundaboutRight,
            "DEPART" => Self::Depart,
            "NAME_CHANGE" => Self::NameChange,
            _ => Self::UnknownValue(maneuver::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for Maneuver {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::TurnSlightLeft => serializer.serialize_i32(1),
            Self::TurnSharpLeft => serializer.serialize_i32(2),
            Self::UturnLeft => serializer.serialize_i32(3),
            Self::TurnLeft => serializer.serialize_i32(4),
            Self::TurnSlightRight => serializer.serialize_i32(5),
            Self::TurnSharpRight => serializer.serialize_i32(6),
            Self::UturnRight => serializer.serialize_i32(7),
            Self::TurnRight => serializer.serialize_i32(8),
            Self::Straight => serializer.serialize_i32(9),
            Self::RampLeft => serializer.serialize_i32(10),
            Self::RampRight => serializer.serialize_i32(11),
            Self::Merge => serializer.serialize_i32(12),
            Self::ForkLeft => serializer.serialize_i32(13),
            Self::ForkRight => serializer.serialize_i32(14),
            Self::Ferry => serializer.serialize_i32(15),
            Self::FerryTrain => serializer.serialize_i32(16),
            Self::RoundaboutLeft => serializer.serialize_i32(17),
            Self::RoundaboutRight => serializer.serialize_i32(18),
            Self::Depart => serializer.serialize_i32(19),
            Self::NameChange => serializer.serialize_i32(20),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

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

/// A set of values that specify the quality of the polyline.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum PolylineQuality {
    /// No polyline quality preference specified. Defaults to `OVERVIEW`.
    Unspecified,
    /// Specifies a high-quality polyline - which is composed using more points
    /// than `OVERVIEW`, at the cost of increased response size. Use this value
    /// when you need more precision.
    HighQuality,
    /// Specifies an overview polyline - which is composed using a small number of
    /// points. Use this value when displaying an overview of the route. Using this
    /// option has a lower request latency compared to using the
    /// `HIGH_QUALITY` option.
    Overview,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [PolylineQuality::value] or
    /// [PolylineQuality::name].
    UnknownValue(polyline_quality::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<i32> for PolylineQuality {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::HighQuality,
            2 => Self::Overview,
            _ => Self::UnknownValue(polyline_quality::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for PolylineQuality {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "POLYLINE_QUALITY_UNSPECIFIED" => Self::Unspecified,
            "HIGH_QUALITY" => Self::HighQuality,
            "OVERVIEW" => Self::Overview,
            _ => Self::UnknownValue(polyline_quality::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

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

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

/// Specifies the preferred type of polyline to be returned.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum PolylineEncoding {
    /// No polyline type preference specified. Defaults to `ENCODED_POLYLINE`.
    Unspecified,
    /// Specifies a polyline encoded using the [polyline encoding
    /// algorithm](/maps/documentation/utilities/polylinealgorithm).
    EncodedPolyline,
    /// Specifies a polyline using the [GeoJSON LineString
    /// format](https://tools.ietf.org/html/rfc7946#section-3.1.4)
    GeoJsonLinestring,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [PolylineEncoding::value] or
    /// [PolylineEncoding::name].
    UnknownValue(polyline_encoding::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<i32> for PolylineEncoding {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::EncodedPolyline,
            2 => Self::GeoJsonLinestring,
            _ => Self::UnknownValue(polyline_encoding::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for PolylineEncoding {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "POLYLINE_ENCODING_UNSPECIFIED" => Self::Unspecified,
            "ENCODED_POLYLINE" => Self::EncodedPolyline,
            "GEO_JSON_LINESTRING" => Self::GeoJsonLinestring,
            _ => Self::UnknownValue(polyline_encoding::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

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

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

/// Labels for the [`Route`][google.maps.routing.v2.Route] that are useful to
/// identify specific properties of the route to compare against others.
///
/// [google.maps.routing.v2.Route]: crate::model::Route
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum RouteLabel {
    /// Default - not used.
    Unspecified,
    /// The default "best" route returned for the route computation.
    DefaultRoute,
    /// An alternative to the default "best" route. Routes like this will be
    /// returned when
    /// [`compute_alternative_routes`][google.maps.routing.v2.ComputeRoutesRequest.compute_alternative_routes]
    /// is specified.
    ///
    /// [google.maps.routing.v2.ComputeRoutesRequest.compute_alternative_routes]: crate::model::ComputeRoutesRequest::compute_alternative_routes
    DefaultRouteAlternate,
    /// Fuel efficient route. Routes labeled with this value are determined to be
    /// optimized for Eco parameters such as fuel consumption.
    FuelEfficient,
    /// Shorter travel distance route. This is an experimental feature.
    ShorterDistance,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [RouteLabel::value] or
    /// [RouteLabel::name].
    UnknownValue(route_label::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<i32> for RouteLabel {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::DefaultRoute,
            2 => Self::DefaultRouteAlternate,
            3 => Self::FuelEfficient,
            4 => Self::ShorterDistance,
            _ => Self::UnknownValue(route_label::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for RouteLabel {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "ROUTE_LABEL_UNSPECIFIED" => Self::Unspecified,
            "DEFAULT_ROUTE" => Self::DefaultRoute,
            "DEFAULT_ROUTE_ALTERNATE" => Self::DefaultRouteAlternate,
            "FUEL_EFFICIENT" => Self::FuelEfficient,
            "SHORTER_DISTANCE" => Self::ShorterDistance,
            _ => Self::UnknownValue(route_label::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

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

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

/// A set of values used to specify the mode of travel.
/// NOTE: `WALK`, `BICYCLE`, and `TWO_WHEELER` routes are in beta and might
/// sometimes be missing clear sidewalks, pedestrian paths, or bicycling paths.
/// You must display this warning to the user for all walking, bicycling, and
/// two-wheel routes that you display in your app.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum RouteTravelMode {
    /// No travel mode specified. Defaults to `DRIVE`.
    TravelModeUnspecified,
    /// Travel by passenger car.
    Drive,
    /// Travel by bicycle.
    Bicycle,
    /// Travel by walking.
    Walk,
    /// Two-wheeled, motorized vehicle. For example, motorcycle. Note that this
    /// differs from the `BICYCLE` travel mode which covers human-powered mode.
    TwoWheeler,
    /// Travel by public transit routes, where available.
    Transit,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [RouteTravelMode::value] or
    /// [RouteTravelMode::name].
    UnknownValue(route_travel_mode::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<i32> for RouteTravelMode {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::TravelModeUnspecified,
            1 => Self::Drive,
            2 => Self::Bicycle,
            3 => Self::Walk,
            4 => Self::TwoWheeler,
            7 => Self::Transit,
            _ => Self::UnknownValue(route_travel_mode::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for RouteTravelMode {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "TRAVEL_MODE_UNSPECIFIED" => Self::TravelModeUnspecified,
            "DRIVE" => Self::Drive,
            "BICYCLE" => Self::Bicycle,
            "WALK" => Self::Walk,
            "TWO_WHEELER" => Self::TwoWheeler,
            "TRANSIT" => Self::Transit,
            _ => Self::UnknownValue(route_travel_mode::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for RouteTravelMode {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::TravelModeUnspecified => serializer.serialize_i32(0),
            Self::Drive => serializer.serialize_i32(1),
            Self::Bicycle => serializer.serialize_i32(2),
            Self::Walk => serializer.serialize_i32(3),
            Self::TwoWheeler => serializer.serialize_i32(4),
            Self::Transit => serializer.serialize_i32(7),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

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

/// The condition of the route being returned.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum RouteMatrixElementCondition {
    /// Only used when the `status` of the element is not OK.
    Unspecified,
    /// A route was found, and the corresponding information was filled out for the
    /// element.
    RouteExists,
    /// No route could be found. Fields containing route information, such as
    /// `distance_meters` or `duration`, will not be filled out in the element.
    RouteNotFound,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [RouteMatrixElementCondition::value] or
    /// [RouteMatrixElementCondition::name].
    UnknownValue(route_matrix_element_condition::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<i32> for RouteMatrixElementCondition {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::RouteExists,
            2 => Self::RouteNotFound,
            _ => Self::UnknownValue(route_matrix_element_condition::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for RouteMatrixElementCondition {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "ROUTE_MATRIX_ELEMENT_CONDITION_UNSPECIFIED" => Self::Unspecified,
            "ROUTE_EXISTS" => Self::RouteExists,
            "ROUTE_NOT_FOUND" => Self::RouteNotFound,
            _ => Self::UnknownValue(route_matrix_element_condition::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

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

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

/// A set of values that specify factors to take into consideration when
/// calculating the route.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum RoutingPreference {
    /// No routing preference specified. Default to `TRAFFIC_UNAWARE`.
    Unspecified,
    /// 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 [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode]
    /// `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.
    ///
    /// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
    TrafficUnaware,
    /// Calculates routes taking live traffic conditions into consideration.
    /// In contrast to `TRAFFIC_AWARE_OPTIMAL`, some optimizations are applied to
    /// significantly reduce latency.
    TrafficAware,
    /// Calculates the routes taking live traffic conditions into consideration,
    /// without applying most performance optimizations. Using this value produces
    /// the highest latency.
    TrafficAwareOptimal,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [RoutingPreference::value] or
    /// [RoutingPreference::name].
    UnknownValue(routing_preference::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<i32> for RoutingPreference {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::TrafficUnaware,
            2 => Self::TrafficAware,
            3 => Self::TrafficAwareOptimal,
            _ => Self::UnknownValue(routing_preference::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for RoutingPreference {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "ROUTING_PREFERENCE_UNSPECIFIED" => Self::Unspecified,
            "TRAFFIC_UNAWARE" => Self::TrafficUnaware,
            "TRAFFIC_AWARE" => Self::TrafficAware,
            "TRAFFIC_AWARE_OPTIMAL" => Self::TrafficAwareOptimal,
            _ => Self::UnknownValue(routing_preference::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

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

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

/// List of toll passes around the world that we support.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum TollPass {
    /// Not used. If this value is used, then the request fails.
    Unspecified,
    /// Sydney toll pass. See additional details at
    /// <https://www.myetoll.com.au>.
    AuEtollTag,
    /// Sydney toll pass. See additional details at <https://www.tollpay.com.au>.
    AuEwayTag,
    /// Australia-wide toll pass.
    /// See additional details at <https://www.linkt.com.au/>.
    AuLinkt,
    /// Argentina toll pass. See additional details at <https://telepase.com.ar>
    ArTelepase,
    /// Brazil toll pass. See additional details at <https://www.autoexpreso.com>
    BrAutoExpreso,
    /// Brazil toll pass. See additional details at <https://conectcar.com>.
    BrConectcar,
    /// Brazil toll pass. See additional details at <https://movemais.com>.
    BrMoveMais,
    /// Brazil toll pass. See additional details at <https://pasorapido.gob.do/>
    BrPassaRapido,
    /// Brazil toll pass. See additional details at <https://www.semparar.com.br>.
    BrSemParar,
    /// Brazil toll pass. See additional details at <https://taggy.com.br>.
    BrTaggy,
    /// Brazil toll pass. See additional details at
    /// <https://veloe.com.br/site/onde-usar>.
    BrVeloe,
    /// Canada to United States border crossing.
    CaUsAkwasasneSeawayCorporateCard,
    /// Canada to United States border crossing.
    CaUsAkwasasneSeawayTransitCard,
    /// Ontario, Canada to Michigan, United States border crossing.
    CaUsBlueWaterEdgePass,
    /// Ontario, Canada to Michigan, United States border crossing.
    CaUsConnexion,
    /// Canada to United States border crossing.
    CaUsNexusCard,
    /// Indonesia.
    /// E-card provided by multiple banks used to pay for tolls. All e-cards
    /// via banks are charged the same so only one enum value is needed. E.g.
    ///
    /// - Bank Mandiri <https://www.bankmandiri.co.id/e-money>
    /// - BCA <https://www.bca.co.id/flazz>
    /// - BNI <https://www.bni.co.id/id-id/ebanking/tapcash>
    IdEToll,
    /// India.
    InFastag,
    /// India, HP state plate exemption.
    InLocalHpPlateExempt,
    /// Japan
    /// ETC. Electronic wireless system to collect tolls.
    /// <https://www.go-etc.jp/>
    JpEtc,
    /// Japan
    /// ETC2.0. New version of ETC with further discount and bidirectional
    /// communication between devices on vehicles and antennas on the road.
    /// <https://www.go-etc.jp/etc2/index.html>
    JpEtc2,
    /// Mexico toll pass.
    /// <https://iave.capufe.gob.mx/#/>
    MxIave,
    /// Mexico
    /// <https://www.pase.com.mx>
    MxPase,
    /// Mexico
    /// <https://operadoravial.com/quick-pass/>
    MxQuickpass,
    /// <http://appsh.chihuahua.gob.mx/transparencia/?doc=/ingresos/TelepeajeFormato4.pdf>
    MxSistemaTelepeajeChihuahua,
    /// Mexico
    MxTagIave,
    /// Mexico toll pass company. One of many operating in Mexico City. See
    /// additional details at <https://www.televia.com.mx>.
    MxTagTelevia,
    /// Mexico toll pass company. One of many operating in Mexico City.
    /// <https://www.televia.com.mx>
    MxTelevia,
    /// Mexico toll pass. See additional details at
    /// <https://www.viapass.com.mx/viapass/web_home.aspx>.
    MxViapass,
    /// AL, USA.
    UsAlFreedomPass,
    /// AK, USA.
    UsAkAntonAndersonTunnelBookOf10Tickets,
    /// CA, USA.
    UsCaFastrak,
    /// Indicates driver has any FasTrak pass in addition to the DMV issued Clean
    /// Air Vehicle (CAV) sticker.
    /// <https://www.bayareafastrak.org/en/guide/doINeedFlex.shtml>
    UsCaFastrakCavSticker,
    /// CO, USA.
    UsCoExpresstoll,
    /// CO, USA.
    UsCoGoPass,
    /// DE, USA.
    UsDeEzpassde,
    /// FL, USA.
    UsFlBobSikesTollBridgePass,
    /// FL, USA.
    UsFlDunesCommunityDevelopmentDistrictExpresscard,
    /// FL, USA.
    UsFlEpass,
    /// FL, USA.
    UsFlGibaTollPass,
    /// FL, USA.
    UsFlLeeway,
    /// FL, USA.
    UsFlSunpass,
    /// FL, USA.
    UsFlSunpassPro,
    /// IL, USA.
    UsIlEzpassil,
    /// IL, USA.
    UsIlIpass,
    /// IN, USA.
    UsInEzpassin,
    /// KS, USA.
    UsKsBestpassHorizon,
    /// KS, USA.
    UsKsKtag,
    /// KS, USA.
    UsKsNationalpass,
    /// KS, USA.
    UsKsPrepassElitepass,
    /// KY, USA.
    UsKyRiverlink,
    /// LA, USA.
    UsLaGeauxpass,
    /// LA, USA.
    UsLaTollTag,
    /// MA, USA.
    UsMaEzpassma,
    /// MD, USA.
    UsMdEzpassmd,
    /// ME, USA.
    UsMeEzpassme,
    /// MI, USA.
    UsMiAmbassadorBridgePremierCommuterCard,
    /// MI, USA.
    UsMiBcpass,
    /// MI, USA.
    UsMiBreakaway,
    /// MI, USA.
    UsMiGrosseIleTollBridgePassTag,
    /// MI, USA.
    /// Deprecated as this pass type no longer exists.
    #[deprecated]
    UsMiIqProxCard,
    /// MI, USA.
    UsMiIqTag,
    /// MI, USA.
    UsMiMackinacBridgeMacPass,
    /// MI, USA.
    UsMiNexpressToll,
    /// MN, USA.
    UsMnEzpassmn,
    /// NC, USA.
    UsNcEzpassnc,
    /// NC, USA.
    UsNcPeachPass,
    /// NC, USA.
    UsNcQuickPass,
    /// NH, USA.
    UsNhEzpassnh,
    /// NJ, USA.
    UsNjDownbeachExpressPass,
    /// NJ, USA.
    UsNjEzpassnj,
    /// NY, USA.
    UsNyExpresspass,
    /// NY, USA.
    UsNyEzpassny,
    /// OH, USA.
    UsOhEzpassoh,
    /// PA, USA.
    UsPaEzpasspa,
    /// RI, USA.
    UsRiEzpassri,
    /// SC, USA.
    UsScPalpass,
    /// TX, USA.
    UsTxAviTag,
    /// TX, USA.
    UsTxBancpass,
    /// TX, USA.
    UsTxDelRioPass,
    /// TX, USA.
    UsTxEfastPass,
    /// TX, USA.
    UsTxEaglePassExpressCard,
    /// TX, USA.
    UsTxEptoll,
    /// TX, USA.
    UsTxEzCross,
    /// TX, USA.
    UsTxEztag,
    /// TX, USA.
    UsTxFuegoTag,
    /// TX, USA.
    UsTxLaredoTradeTag,
    /// TX, USA.
    UsTxPluspass,
    /// TX, USA.
    UsTxTolltag,
    /// TX, USA.
    UsTxTxtag,
    /// TX, USA.
    UsTxXpressCard,
    /// UT, USA.
    UsUtAdamsAveParkwayExpresscard,
    /// VA, USA.
    UsVaEzpassva,
    /// WA, USA.
    UsWaBreezeby,
    /// WA, USA.
    UsWaGoodToGo,
    /// WV, USA.
    UsWvEzpasswv,
    /// WV, USA.
    UsWvMemorialBridgeTickets,
    /// WV, USA
    UsWvMovPass,
    /// WV, USA.
    UsWvNewellTollBridgeTicket,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [TollPass::value] or
    /// [TollPass::name].
    UnknownValue(toll_pass::UnknownValue),
}

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

impl TollPass {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::AuEtollTag => std::option::Option::Some(82),
            Self::AuEwayTag => std::option::Option::Some(83),
            Self::AuLinkt => std::option::Option::Some(2),
            Self::ArTelepase => std::option::Option::Some(3),
            Self::BrAutoExpreso => std::option::Option::Some(81),
            Self::BrConectcar => std::option::Option::Some(7),
            Self::BrMoveMais => std::option::Option::Some(8),
            Self::BrPassaRapido => std::option::Option::Some(88),
            Self::BrSemParar => std::option::Option::Some(9),
            Self::BrTaggy => std::option::Option::Some(10),
            Self::BrVeloe => std::option::Option::Some(11),
            Self::CaUsAkwasasneSeawayCorporateCard => std::option::Option::Some(84),
            Self::CaUsAkwasasneSeawayTransitCard => std::option::Option::Some(85),
            Self::CaUsBlueWaterEdgePass => std::option::Option::Some(18),
            Self::CaUsConnexion => std::option::Option::Some(19),
            Self::CaUsNexusCard => std::option::Option::Some(20),
            Self::IdEToll => std::option::Option::Some(16),
            Self::InFastag => std::option::Option::Some(78),
            Self::InLocalHpPlateExempt => std::option::Option::Some(79),
            Self::JpEtc => std::option::Option::Some(98),
            Self::JpEtc2 => std::option::Option::Some(99),
            Self::MxIave => std::option::Option::Some(90),
            Self::MxPase => std::option::Option::Some(91),
            Self::MxQuickpass => std::option::Option::Some(93),
            Self::MxSistemaTelepeajeChihuahua => std::option::Option::Some(89),
            Self::MxTagIave => std::option::Option::Some(12),
            Self::MxTagTelevia => std::option::Option::Some(13),
            Self::MxTelevia => std::option::Option::Some(92),
            Self::MxViapass => std::option::Option::Some(14),
            Self::UsAlFreedomPass => std::option::Option::Some(21),
            Self::UsAkAntonAndersonTunnelBookOf10Tickets => std::option::Option::Some(22),
            Self::UsCaFastrak => std::option::Option::Some(4),
            Self::UsCaFastrakCavSticker => std::option::Option::Some(86),
            Self::UsCoExpresstoll => std::option::Option::Some(23),
            Self::UsCoGoPass => std::option::Option::Some(24),
            Self::UsDeEzpassde => std::option::Option::Some(25),
            Self::UsFlBobSikesTollBridgePass => std::option::Option::Some(65),
            Self::UsFlDunesCommunityDevelopmentDistrictExpresscard => std::option::Option::Some(66),
            Self::UsFlEpass => std::option::Option::Some(67),
            Self::UsFlGibaTollPass => std::option::Option::Some(68),
            Self::UsFlLeeway => std::option::Option::Some(69),
            Self::UsFlSunpass => std::option::Option::Some(70),
            Self::UsFlSunpassPro => std::option::Option::Some(71),
            Self::UsIlEzpassil => std::option::Option::Some(73),
            Self::UsIlIpass => std::option::Option::Some(72),
            Self::UsInEzpassin => std::option::Option::Some(26),
            Self::UsKsBestpassHorizon => std::option::Option::Some(27),
            Self::UsKsKtag => std::option::Option::Some(28),
            Self::UsKsNationalpass => std::option::Option::Some(29),
            Self::UsKsPrepassElitepass => std::option::Option::Some(30),
            Self::UsKyRiverlink => std::option::Option::Some(31),
            Self::UsLaGeauxpass => std::option::Option::Some(32),
            Self::UsLaTollTag => std::option::Option::Some(33),
            Self::UsMaEzpassma => std::option::Option::Some(6),
            Self::UsMdEzpassmd => std::option::Option::Some(34),
            Self::UsMeEzpassme => std::option::Option::Some(35),
            Self::UsMiAmbassadorBridgePremierCommuterCard => std::option::Option::Some(36),
            Self::UsMiBcpass => std::option::Option::Some(94),
            Self::UsMiBreakaway => std::option::Option::Some(101),
            Self::UsMiGrosseIleTollBridgePassTag => std::option::Option::Some(37),
            Self::UsMiIqProxCard => std::option::Option::Some(38),
            Self::UsMiIqTag => std::option::Option::Some(95),
            Self::UsMiMackinacBridgeMacPass => std::option::Option::Some(39),
            Self::UsMiNexpressToll => std::option::Option::Some(40),
            Self::UsMnEzpassmn => std::option::Option::Some(41),
            Self::UsNcEzpassnc => std::option::Option::Some(42),
            Self::UsNcPeachPass => std::option::Option::Some(87),
            Self::UsNcQuickPass => std::option::Option::Some(43),
            Self::UsNhEzpassnh => std::option::Option::Some(80),
            Self::UsNjDownbeachExpressPass => std::option::Option::Some(75),
            Self::UsNjEzpassnj => std::option::Option::Some(74),
            Self::UsNyExpresspass => std::option::Option::Some(76),
            Self::UsNyEzpassny => std::option::Option::Some(77),
            Self::UsOhEzpassoh => std::option::Option::Some(44),
            Self::UsPaEzpasspa => std::option::Option::Some(45),
            Self::UsRiEzpassri => std::option::Option::Some(46),
            Self::UsScPalpass => std::option::Option::Some(47),
            Self::UsTxAviTag => std::option::Option::Some(97),
            Self::UsTxBancpass => std::option::Option::Some(48),
            Self::UsTxDelRioPass => std::option::Option::Some(49),
            Self::UsTxEfastPass => std::option::Option::Some(50),
            Self::UsTxEaglePassExpressCard => std::option::Option::Some(51),
            Self::UsTxEptoll => std::option::Option::Some(52),
            Self::UsTxEzCross => std::option::Option::Some(53),
            Self::UsTxEztag => std::option::Option::Some(54),
            Self::UsTxFuegoTag => std::option::Option::Some(96),
            Self::UsTxLaredoTradeTag => std::option::Option::Some(55),
            Self::UsTxPluspass => std::option::Option::Some(56),
            Self::UsTxTolltag => std::option::Option::Some(57),
            Self::UsTxTxtag => std::option::Option::Some(58),
            Self::UsTxXpressCard => std::option::Option::Some(59),
            Self::UsUtAdamsAveParkwayExpresscard => std::option::Option::Some(60),
            Self::UsVaEzpassva => std::option::Option::Some(61),
            Self::UsWaBreezeby => std::option::Option::Some(17),
            Self::UsWaGoodToGo => std::option::Option::Some(1),
            Self::UsWvEzpasswv => std::option::Option::Some(62),
            Self::UsWvMemorialBridgeTickets => std::option::Option::Some(63),
            Self::UsWvMovPass => std::option::Option::Some(100),
            Self::UsWvNewellTollBridgeTicket => std::option::Option::Some(64),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("TOLL_PASS_UNSPECIFIED"),
            Self::AuEtollTag => std::option::Option::Some("AU_ETOLL_TAG"),
            Self::AuEwayTag => std::option::Option::Some("AU_EWAY_TAG"),
            Self::AuLinkt => std::option::Option::Some("AU_LINKT"),
            Self::ArTelepase => std::option::Option::Some("AR_TELEPASE"),
            Self::BrAutoExpreso => std::option::Option::Some("BR_AUTO_EXPRESO"),
            Self::BrConectcar => std::option::Option::Some("BR_CONECTCAR"),
            Self::BrMoveMais => std::option::Option::Some("BR_MOVE_MAIS"),
            Self::BrPassaRapido => std::option::Option::Some("BR_PASSA_RAPIDO"),
            Self::BrSemParar => std::option::Option::Some("BR_SEM_PARAR"),
            Self::BrTaggy => std::option::Option::Some("BR_TAGGY"),
            Self::BrVeloe => std::option::Option::Some("BR_VELOE"),
            Self::CaUsAkwasasneSeawayCorporateCard => {
                std::option::Option::Some("CA_US_AKWASASNE_SEAWAY_CORPORATE_CARD")
            }
            Self::CaUsAkwasasneSeawayTransitCard => {
                std::option::Option::Some("CA_US_AKWASASNE_SEAWAY_TRANSIT_CARD")
            }
            Self::CaUsBlueWaterEdgePass => std::option::Option::Some("CA_US_BLUE_WATER_EDGE_PASS"),
            Self::CaUsConnexion => std::option::Option::Some("CA_US_CONNEXION"),
            Self::CaUsNexusCard => std::option::Option::Some("CA_US_NEXUS_CARD"),
            Self::IdEToll => std::option::Option::Some("ID_E_TOLL"),
            Self::InFastag => std::option::Option::Some("IN_FASTAG"),
            Self::InLocalHpPlateExempt => std::option::Option::Some("IN_LOCAL_HP_PLATE_EXEMPT"),
            Self::JpEtc => std::option::Option::Some("JP_ETC"),
            Self::JpEtc2 => std::option::Option::Some("JP_ETC2"),
            Self::MxIave => std::option::Option::Some("MX_IAVE"),
            Self::MxPase => std::option::Option::Some("MX_PASE"),
            Self::MxQuickpass => std::option::Option::Some("MX_QUICKPASS"),
            Self::MxSistemaTelepeajeChihuahua => {
                std::option::Option::Some("MX_SISTEMA_TELEPEAJE_CHIHUAHUA")
            }
            Self::MxTagIave => std::option::Option::Some("MX_TAG_IAVE"),
            Self::MxTagTelevia => std::option::Option::Some("MX_TAG_TELEVIA"),
            Self::MxTelevia => std::option::Option::Some("MX_TELEVIA"),
            Self::MxViapass => std::option::Option::Some("MX_VIAPASS"),
            Self::UsAlFreedomPass => std::option::Option::Some("US_AL_FREEDOM_PASS"),
            Self::UsAkAntonAndersonTunnelBookOf10Tickets => {
                std::option::Option::Some("US_AK_ANTON_ANDERSON_TUNNEL_BOOK_OF_10_TICKETS")
            }
            Self::UsCaFastrak => std::option::Option::Some("US_CA_FASTRAK"),
            Self::UsCaFastrakCavSticker => std::option::Option::Some("US_CA_FASTRAK_CAV_STICKER"),
            Self::UsCoExpresstoll => std::option::Option::Some("US_CO_EXPRESSTOLL"),
            Self::UsCoGoPass => std::option::Option::Some("US_CO_GO_PASS"),
            Self::UsDeEzpassde => std::option::Option::Some("US_DE_EZPASSDE"),
            Self::UsFlBobSikesTollBridgePass => {
                std::option::Option::Some("US_FL_BOB_SIKES_TOLL_BRIDGE_PASS")
            }
            Self::UsFlDunesCommunityDevelopmentDistrictExpresscard => {
                std::option::Option::Some("US_FL_DUNES_COMMUNITY_DEVELOPMENT_DISTRICT_EXPRESSCARD")
            }
            Self::UsFlEpass => std::option::Option::Some("US_FL_EPASS"),
            Self::UsFlGibaTollPass => std::option::Option::Some("US_FL_GIBA_TOLL_PASS"),
            Self::UsFlLeeway => std::option::Option::Some("US_FL_LEEWAY"),
            Self::UsFlSunpass => std::option::Option::Some("US_FL_SUNPASS"),
            Self::UsFlSunpassPro => std::option::Option::Some("US_FL_SUNPASS_PRO"),
            Self::UsIlEzpassil => std::option::Option::Some("US_IL_EZPASSIL"),
            Self::UsIlIpass => std::option::Option::Some("US_IL_IPASS"),
            Self::UsInEzpassin => std::option::Option::Some("US_IN_EZPASSIN"),
            Self::UsKsBestpassHorizon => std::option::Option::Some("US_KS_BESTPASS_HORIZON"),
            Self::UsKsKtag => std::option::Option::Some("US_KS_KTAG"),
            Self::UsKsNationalpass => std::option::Option::Some("US_KS_NATIONALPASS"),
            Self::UsKsPrepassElitepass => std::option::Option::Some("US_KS_PREPASS_ELITEPASS"),
            Self::UsKyRiverlink => std::option::Option::Some("US_KY_RIVERLINK"),
            Self::UsLaGeauxpass => std::option::Option::Some("US_LA_GEAUXPASS"),
            Self::UsLaTollTag => std::option::Option::Some("US_LA_TOLL_TAG"),
            Self::UsMaEzpassma => std::option::Option::Some("US_MA_EZPASSMA"),
            Self::UsMdEzpassmd => std::option::Option::Some("US_MD_EZPASSMD"),
            Self::UsMeEzpassme => std::option::Option::Some("US_ME_EZPASSME"),
            Self::UsMiAmbassadorBridgePremierCommuterCard => {
                std::option::Option::Some("US_MI_AMBASSADOR_BRIDGE_PREMIER_COMMUTER_CARD")
            }
            Self::UsMiBcpass => std::option::Option::Some("US_MI_BCPASS"),
            Self::UsMiBreakaway => std::option::Option::Some("US_MI_BREAKAWAY"),
            Self::UsMiGrosseIleTollBridgePassTag => {
                std::option::Option::Some("US_MI_GROSSE_ILE_TOLL_BRIDGE_PASS_TAG")
            }
            Self::UsMiIqProxCard => std::option::Option::Some("US_MI_IQ_PROX_CARD"),
            Self::UsMiIqTag => std::option::Option::Some("US_MI_IQ_TAG"),
            Self::UsMiMackinacBridgeMacPass => {
                std::option::Option::Some("US_MI_MACKINAC_BRIDGE_MAC_PASS")
            }
            Self::UsMiNexpressToll => std::option::Option::Some("US_MI_NEXPRESS_TOLL"),
            Self::UsMnEzpassmn => std::option::Option::Some("US_MN_EZPASSMN"),
            Self::UsNcEzpassnc => std::option::Option::Some("US_NC_EZPASSNC"),
            Self::UsNcPeachPass => std::option::Option::Some("US_NC_PEACH_PASS"),
            Self::UsNcQuickPass => std::option::Option::Some("US_NC_QUICK_PASS"),
            Self::UsNhEzpassnh => std::option::Option::Some("US_NH_EZPASSNH"),
            Self::UsNjDownbeachExpressPass => {
                std::option::Option::Some("US_NJ_DOWNBEACH_EXPRESS_PASS")
            }
            Self::UsNjEzpassnj => std::option::Option::Some("US_NJ_EZPASSNJ"),
            Self::UsNyExpresspass => std::option::Option::Some("US_NY_EXPRESSPASS"),
            Self::UsNyEzpassny => std::option::Option::Some("US_NY_EZPASSNY"),
            Self::UsOhEzpassoh => std::option::Option::Some("US_OH_EZPASSOH"),
            Self::UsPaEzpasspa => std::option::Option::Some("US_PA_EZPASSPA"),
            Self::UsRiEzpassri => std::option::Option::Some("US_RI_EZPASSRI"),
            Self::UsScPalpass => std::option::Option::Some("US_SC_PALPASS"),
            Self::UsTxAviTag => std::option::Option::Some("US_TX_AVI_TAG"),
            Self::UsTxBancpass => std::option::Option::Some("US_TX_BANCPASS"),
            Self::UsTxDelRioPass => std::option::Option::Some("US_TX_DEL_RIO_PASS"),
            Self::UsTxEfastPass => std::option::Option::Some("US_TX_EFAST_PASS"),
            Self::UsTxEaglePassExpressCard => {
                std::option::Option::Some("US_TX_EAGLE_PASS_EXPRESS_CARD")
            }
            Self::UsTxEptoll => std::option::Option::Some("US_TX_EPTOLL"),
            Self::UsTxEzCross => std::option::Option::Some("US_TX_EZ_CROSS"),
            Self::UsTxEztag => std::option::Option::Some("US_TX_EZTAG"),
            Self::UsTxFuegoTag => std::option::Option::Some("US_TX_FUEGO_TAG"),
            Self::UsTxLaredoTradeTag => std::option::Option::Some("US_TX_LAREDO_TRADE_TAG"),
            Self::UsTxPluspass => std::option::Option::Some("US_TX_PLUSPASS"),
            Self::UsTxTolltag => std::option::Option::Some("US_TX_TOLLTAG"),
            Self::UsTxTxtag => std::option::Option::Some("US_TX_TXTAG"),
            Self::UsTxXpressCard => std::option::Option::Some("US_TX_XPRESS_CARD"),
            Self::UsUtAdamsAveParkwayExpresscard => {
                std::option::Option::Some("US_UT_ADAMS_AVE_PARKWAY_EXPRESSCARD")
            }
            Self::UsVaEzpassva => std::option::Option::Some("US_VA_EZPASSVA"),
            Self::UsWaBreezeby => std::option::Option::Some("US_WA_BREEZEBY"),
            Self::UsWaGoodToGo => std::option::Option::Some("US_WA_GOOD_TO_GO"),
            Self::UsWvEzpasswv => std::option::Option::Some("US_WV_EZPASSWV"),
            Self::UsWvMemorialBridgeTickets => {
                std::option::Option::Some("US_WV_MEMORIAL_BRIDGE_TICKETS")
            }
            Self::UsWvMovPass => std::option::Option::Some("US_WV_MOV_PASS"),
            Self::UsWvNewellTollBridgeTicket => {
                std::option::Option::Some("US_WV_NEWELL_TOLL_BRIDGE_TICKET")
            }
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

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

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

impl std::convert::From<i32> for TollPass {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::UsWaGoodToGo,
            2 => Self::AuLinkt,
            3 => Self::ArTelepase,
            4 => Self::UsCaFastrak,
            6 => Self::UsMaEzpassma,
            7 => Self::BrConectcar,
            8 => Self::BrMoveMais,
            9 => Self::BrSemParar,
            10 => Self::BrTaggy,
            11 => Self::BrVeloe,
            12 => Self::MxTagIave,
            13 => Self::MxTagTelevia,
            14 => Self::MxViapass,
            16 => Self::IdEToll,
            17 => Self::UsWaBreezeby,
            18 => Self::CaUsBlueWaterEdgePass,
            19 => Self::CaUsConnexion,
            20 => Self::CaUsNexusCard,
            21 => Self::UsAlFreedomPass,
            22 => Self::UsAkAntonAndersonTunnelBookOf10Tickets,
            23 => Self::UsCoExpresstoll,
            24 => Self::UsCoGoPass,
            25 => Self::UsDeEzpassde,
            26 => Self::UsInEzpassin,
            27 => Self::UsKsBestpassHorizon,
            28 => Self::UsKsKtag,
            29 => Self::UsKsNationalpass,
            30 => Self::UsKsPrepassElitepass,
            31 => Self::UsKyRiverlink,
            32 => Self::UsLaGeauxpass,
            33 => Self::UsLaTollTag,
            34 => Self::UsMdEzpassmd,
            35 => Self::UsMeEzpassme,
            36 => Self::UsMiAmbassadorBridgePremierCommuterCard,
            37 => Self::UsMiGrosseIleTollBridgePassTag,
            38 => Self::UsMiIqProxCard,
            39 => Self::UsMiMackinacBridgeMacPass,
            40 => Self::UsMiNexpressToll,
            41 => Self::UsMnEzpassmn,
            42 => Self::UsNcEzpassnc,
            43 => Self::UsNcQuickPass,
            44 => Self::UsOhEzpassoh,
            45 => Self::UsPaEzpasspa,
            46 => Self::UsRiEzpassri,
            47 => Self::UsScPalpass,
            48 => Self::UsTxBancpass,
            49 => Self::UsTxDelRioPass,
            50 => Self::UsTxEfastPass,
            51 => Self::UsTxEaglePassExpressCard,
            52 => Self::UsTxEptoll,
            53 => Self::UsTxEzCross,
            54 => Self::UsTxEztag,
            55 => Self::UsTxLaredoTradeTag,
            56 => Self::UsTxPluspass,
            57 => Self::UsTxTolltag,
            58 => Self::UsTxTxtag,
            59 => Self::UsTxXpressCard,
            60 => Self::UsUtAdamsAveParkwayExpresscard,
            61 => Self::UsVaEzpassva,
            62 => Self::UsWvEzpasswv,
            63 => Self::UsWvMemorialBridgeTickets,
            64 => Self::UsWvNewellTollBridgeTicket,
            65 => Self::UsFlBobSikesTollBridgePass,
            66 => Self::UsFlDunesCommunityDevelopmentDistrictExpresscard,
            67 => Self::UsFlEpass,
            68 => Self::UsFlGibaTollPass,
            69 => Self::UsFlLeeway,
            70 => Self::UsFlSunpass,
            71 => Self::UsFlSunpassPro,
            72 => Self::UsIlIpass,
            73 => Self::UsIlEzpassil,
            74 => Self::UsNjEzpassnj,
            75 => Self::UsNjDownbeachExpressPass,
            76 => Self::UsNyExpresspass,
            77 => Self::UsNyEzpassny,
            78 => Self::InFastag,
            79 => Self::InLocalHpPlateExempt,
            80 => Self::UsNhEzpassnh,
            81 => Self::BrAutoExpreso,
            82 => Self::AuEtollTag,
            83 => Self::AuEwayTag,
            84 => Self::CaUsAkwasasneSeawayCorporateCard,
            85 => Self::CaUsAkwasasneSeawayTransitCard,
            86 => Self::UsCaFastrakCavSticker,
            87 => Self::UsNcPeachPass,
            88 => Self::BrPassaRapido,
            89 => Self::MxSistemaTelepeajeChihuahua,
            90 => Self::MxIave,
            91 => Self::MxPase,
            92 => Self::MxTelevia,
            93 => Self::MxQuickpass,
            94 => Self::UsMiBcpass,
            95 => Self::UsMiIqTag,
            96 => Self::UsTxFuegoTag,
            97 => Self::UsTxAviTag,
            98 => Self::JpEtc,
            99 => Self::JpEtc2,
            100 => Self::UsWvMovPass,
            101 => Self::UsMiBreakaway,
            _ => Self::UnknownValue(toll_pass::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for TollPass {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "TOLL_PASS_UNSPECIFIED" => Self::Unspecified,
            "AU_ETOLL_TAG" => Self::AuEtollTag,
            "AU_EWAY_TAG" => Self::AuEwayTag,
            "AU_LINKT" => Self::AuLinkt,
            "AR_TELEPASE" => Self::ArTelepase,
            "BR_AUTO_EXPRESO" => Self::BrAutoExpreso,
            "BR_CONECTCAR" => Self::BrConectcar,
            "BR_MOVE_MAIS" => Self::BrMoveMais,
            "BR_PASSA_RAPIDO" => Self::BrPassaRapido,
            "BR_SEM_PARAR" => Self::BrSemParar,
            "BR_TAGGY" => Self::BrTaggy,
            "BR_VELOE" => Self::BrVeloe,
            "CA_US_AKWASASNE_SEAWAY_CORPORATE_CARD" => Self::CaUsAkwasasneSeawayCorporateCard,
            "CA_US_AKWASASNE_SEAWAY_TRANSIT_CARD" => Self::CaUsAkwasasneSeawayTransitCard,
            "CA_US_BLUE_WATER_EDGE_PASS" => Self::CaUsBlueWaterEdgePass,
            "CA_US_CONNEXION" => Self::CaUsConnexion,
            "CA_US_NEXUS_CARD" => Self::CaUsNexusCard,
            "ID_E_TOLL" => Self::IdEToll,
            "IN_FASTAG" => Self::InFastag,
            "IN_LOCAL_HP_PLATE_EXEMPT" => Self::InLocalHpPlateExempt,
            "JP_ETC" => Self::JpEtc,
            "JP_ETC2" => Self::JpEtc2,
            "MX_IAVE" => Self::MxIave,
            "MX_PASE" => Self::MxPase,
            "MX_QUICKPASS" => Self::MxQuickpass,
            "MX_SISTEMA_TELEPEAJE_CHIHUAHUA" => Self::MxSistemaTelepeajeChihuahua,
            "MX_TAG_IAVE" => Self::MxTagIave,
            "MX_TAG_TELEVIA" => Self::MxTagTelevia,
            "MX_TELEVIA" => Self::MxTelevia,
            "MX_VIAPASS" => Self::MxViapass,
            "US_AL_FREEDOM_PASS" => Self::UsAlFreedomPass,
            "US_AK_ANTON_ANDERSON_TUNNEL_BOOK_OF_10_TICKETS" => {
                Self::UsAkAntonAndersonTunnelBookOf10Tickets
            }
            "US_CA_FASTRAK" => Self::UsCaFastrak,
            "US_CA_FASTRAK_CAV_STICKER" => Self::UsCaFastrakCavSticker,
            "US_CO_EXPRESSTOLL" => Self::UsCoExpresstoll,
            "US_CO_GO_PASS" => Self::UsCoGoPass,
            "US_DE_EZPASSDE" => Self::UsDeEzpassde,
            "US_FL_BOB_SIKES_TOLL_BRIDGE_PASS" => Self::UsFlBobSikesTollBridgePass,
            "US_FL_DUNES_COMMUNITY_DEVELOPMENT_DISTRICT_EXPRESSCARD" => {
                Self::UsFlDunesCommunityDevelopmentDistrictExpresscard
            }
            "US_FL_EPASS" => Self::UsFlEpass,
            "US_FL_GIBA_TOLL_PASS" => Self::UsFlGibaTollPass,
            "US_FL_LEEWAY" => Self::UsFlLeeway,
            "US_FL_SUNPASS" => Self::UsFlSunpass,
            "US_FL_SUNPASS_PRO" => Self::UsFlSunpassPro,
            "US_IL_EZPASSIL" => Self::UsIlEzpassil,
            "US_IL_IPASS" => Self::UsIlIpass,
            "US_IN_EZPASSIN" => Self::UsInEzpassin,
            "US_KS_BESTPASS_HORIZON" => Self::UsKsBestpassHorizon,
            "US_KS_KTAG" => Self::UsKsKtag,
            "US_KS_NATIONALPASS" => Self::UsKsNationalpass,
            "US_KS_PREPASS_ELITEPASS" => Self::UsKsPrepassElitepass,
            "US_KY_RIVERLINK" => Self::UsKyRiverlink,
            "US_LA_GEAUXPASS" => Self::UsLaGeauxpass,
            "US_LA_TOLL_TAG" => Self::UsLaTollTag,
            "US_MA_EZPASSMA" => Self::UsMaEzpassma,
            "US_MD_EZPASSMD" => Self::UsMdEzpassmd,
            "US_ME_EZPASSME" => Self::UsMeEzpassme,
            "US_MI_AMBASSADOR_BRIDGE_PREMIER_COMMUTER_CARD" => {
                Self::UsMiAmbassadorBridgePremierCommuterCard
            }
            "US_MI_BCPASS" => Self::UsMiBcpass,
            "US_MI_BREAKAWAY" => Self::UsMiBreakaway,
            "US_MI_GROSSE_ILE_TOLL_BRIDGE_PASS_TAG" => Self::UsMiGrosseIleTollBridgePassTag,
            "US_MI_IQ_PROX_CARD" => Self::UsMiIqProxCard,
            "US_MI_IQ_TAG" => Self::UsMiIqTag,
            "US_MI_MACKINAC_BRIDGE_MAC_PASS" => Self::UsMiMackinacBridgeMacPass,
            "US_MI_NEXPRESS_TOLL" => Self::UsMiNexpressToll,
            "US_MN_EZPASSMN" => Self::UsMnEzpassmn,
            "US_NC_EZPASSNC" => Self::UsNcEzpassnc,
            "US_NC_PEACH_PASS" => Self::UsNcPeachPass,
            "US_NC_QUICK_PASS" => Self::UsNcQuickPass,
            "US_NH_EZPASSNH" => Self::UsNhEzpassnh,
            "US_NJ_DOWNBEACH_EXPRESS_PASS" => Self::UsNjDownbeachExpressPass,
            "US_NJ_EZPASSNJ" => Self::UsNjEzpassnj,
            "US_NY_EXPRESSPASS" => Self::UsNyExpresspass,
            "US_NY_EZPASSNY" => Self::UsNyEzpassny,
            "US_OH_EZPASSOH" => Self::UsOhEzpassoh,
            "US_PA_EZPASSPA" => Self::UsPaEzpasspa,
            "US_RI_EZPASSRI" => Self::UsRiEzpassri,
            "US_SC_PALPASS" => Self::UsScPalpass,
            "US_TX_AVI_TAG" => Self::UsTxAviTag,
            "US_TX_BANCPASS" => Self::UsTxBancpass,
            "US_TX_DEL_RIO_PASS" => Self::UsTxDelRioPass,
            "US_TX_EFAST_PASS" => Self::UsTxEfastPass,
            "US_TX_EAGLE_PASS_EXPRESS_CARD" => Self::UsTxEaglePassExpressCard,
            "US_TX_EPTOLL" => Self::UsTxEptoll,
            "US_TX_EZ_CROSS" => Self::UsTxEzCross,
            "US_TX_EZTAG" => Self::UsTxEztag,
            "US_TX_FUEGO_TAG" => Self::UsTxFuegoTag,
            "US_TX_LAREDO_TRADE_TAG" => Self::UsTxLaredoTradeTag,
            "US_TX_PLUSPASS" => Self::UsTxPluspass,
            "US_TX_TOLLTAG" => Self::UsTxTolltag,
            "US_TX_TXTAG" => Self::UsTxTxtag,
            "US_TX_XPRESS_CARD" => Self::UsTxXpressCard,
            "US_UT_ADAMS_AVE_PARKWAY_EXPRESSCARD" => Self::UsUtAdamsAveParkwayExpresscard,
            "US_VA_EZPASSVA" => Self::UsVaEzpassva,
            "US_WA_BREEZEBY" => Self::UsWaBreezeby,
            "US_WA_GOOD_TO_GO" => Self::UsWaGoodToGo,
            "US_WV_EZPASSWV" => Self::UsWvEzpasswv,
            "US_WV_MEMORIAL_BRIDGE_TICKETS" => Self::UsWvMemorialBridgeTickets,
            "US_WV_MOV_PASS" => Self::UsWvMovPass,
            "US_WV_NEWELL_TOLL_BRIDGE_TICKET" => Self::UsWvNewellTollBridgeTicket,
            _ => Self::UnknownValue(toll_pass::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for TollPass {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::AuEtollTag => serializer.serialize_i32(82),
            Self::AuEwayTag => serializer.serialize_i32(83),
            Self::AuLinkt => serializer.serialize_i32(2),
            Self::ArTelepase => serializer.serialize_i32(3),
            Self::BrAutoExpreso => serializer.serialize_i32(81),
            Self::BrConectcar => serializer.serialize_i32(7),
            Self::BrMoveMais => serializer.serialize_i32(8),
            Self::BrPassaRapido => serializer.serialize_i32(88),
            Self::BrSemParar => serializer.serialize_i32(9),
            Self::BrTaggy => serializer.serialize_i32(10),
            Self::BrVeloe => serializer.serialize_i32(11),
            Self::CaUsAkwasasneSeawayCorporateCard => serializer.serialize_i32(84),
            Self::CaUsAkwasasneSeawayTransitCard => serializer.serialize_i32(85),
            Self::CaUsBlueWaterEdgePass => serializer.serialize_i32(18),
            Self::CaUsConnexion => serializer.serialize_i32(19),
            Self::CaUsNexusCard => serializer.serialize_i32(20),
            Self::IdEToll => serializer.serialize_i32(16),
            Self::InFastag => serializer.serialize_i32(78),
            Self::InLocalHpPlateExempt => serializer.serialize_i32(79),
            Self::JpEtc => serializer.serialize_i32(98),
            Self::JpEtc2 => serializer.serialize_i32(99),
            Self::MxIave => serializer.serialize_i32(90),
            Self::MxPase => serializer.serialize_i32(91),
            Self::MxQuickpass => serializer.serialize_i32(93),
            Self::MxSistemaTelepeajeChihuahua => serializer.serialize_i32(89),
            Self::MxTagIave => serializer.serialize_i32(12),
            Self::MxTagTelevia => serializer.serialize_i32(13),
            Self::MxTelevia => serializer.serialize_i32(92),
            Self::MxViapass => serializer.serialize_i32(14),
            Self::UsAlFreedomPass => serializer.serialize_i32(21),
            Self::UsAkAntonAndersonTunnelBookOf10Tickets => serializer.serialize_i32(22),
            Self::UsCaFastrak => serializer.serialize_i32(4),
            Self::UsCaFastrakCavSticker => serializer.serialize_i32(86),
            Self::UsCoExpresstoll => serializer.serialize_i32(23),
            Self::UsCoGoPass => serializer.serialize_i32(24),
            Self::UsDeEzpassde => serializer.serialize_i32(25),
            Self::UsFlBobSikesTollBridgePass => serializer.serialize_i32(65),
            Self::UsFlDunesCommunityDevelopmentDistrictExpresscard => serializer.serialize_i32(66),
            Self::UsFlEpass => serializer.serialize_i32(67),
            Self::UsFlGibaTollPass => serializer.serialize_i32(68),
            Self::UsFlLeeway => serializer.serialize_i32(69),
            Self::UsFlSunpass => serializer.serialize_i32(70),
            Self::UsFlSunpassPro => serializer.serialize_i32(71),
            Self::UsIlEzpassil => serializer.serialize_i32(73),
            Self::UsIlIpass => serializer.serialize_i32(72),
            Self::UsInEzpassin => serializer.serialize_i32(26),
            Self::UsKsBestpassHorizon => serializer.serialize_i32(27),
            Self::UsKsKtag => serializer.serialize_i32(28),
            Self::UsKsNationalpass => serializer.serialize_i32(29),
            Self::UsKsPrepassElitepass => serializer.serialize_i32(30),
            Self::UsKyRiverlink => serializer.serialize_i32(31),
            Self::UsLaGeauxpass => serializer.serialize_i32(32),
            Self::UsLaTollTag => serializer.serialize_i32(33),
            Self::UsMaEzpassma => serializer.serialize_i32(6),
            Self::UsMdEzpassmd => serializer.serialize_i32(34),
            Self::UsMeEzpassme => serializer.serialize_i32(35),
            Self::UsMiAmbassadorBridgePremierCommuterCard => serializer.serialize_i32(36),
            Self::UsMiBcpass => serializer.serialize_i32(94),
            Self::UsMiBreakaway => serializer.serialize_i32(101),
            Self::UsMiGrosseIleTollBridgePassTag => serializer.serialize_i32(37),
            Self::UsMiIqProxCard => serializer.serialize_i32(38),
            Self::UsMiIqTag => serializer.serialize_i32(95),
            Self::UsMiMackinacBridgeMacPass => serializer.serialize_i32(39),
            Self::UsMiNexpressToll => serializer.serialize_i32(40),
            Self::UsMnEzpassmn => serializer.serialize_i32(41),
            Self::UsNcEzpassnc => serializer.serialize_i32(42),
            Self::UsNcPeachPass => serializer.serialize_i32(87),
            Self::UsNcQuickPass => serializer.serialize_i32(43),
            Self::UsNhEzpassnh => serializer.serialize_i32(80),
            Self::UsNjDownbeachExpressPass => serializer.serialize_i32(75),
            Self::UsNjEzpassnj => serializer.serialize_i32(74),
            Self::UsNyExpresspass => serializer.serialize_i32(76),
            Self::UsNyEzpassny => serializer.serialize_i32(77),
            Self::UsOhEzpassoh => serializer.serialize_i32(44),
            Self::UsPaEzpasspa => serializer.serialize_i32(45),
            Self::UsRiEzpassri => serializer.serialize_i32(46),
            Self::UsScPalpass => serializer.serialize_i32(47),
            Self::UsTxAviTag => serializer.serialize_i32(97),
            Self::UsTxBancpass => serializer.serialize_i32(48),
            Self::UsTxDelRioPass => serializer.serialize_i32(49),
            Self::UsTxEfastPass => serializer.serialize_i32(50),
            Self::UsTxEaglePassExpressCard => serializer.serialize_i32(51),
            Self::UsTxEptoll => serializer.serialize_i32(52),
            Self::UsTxEzCross => serializer.serialize_i32(53),
            Self::UsTxEztag => serializer.serialize_i32(54),
            Self::UsTxFuegoTag => serializer.serialize_i32(96),
            Self::UsTxLaredoTradeTag => serializer.serialize_i32(55),
            Self::UsTxPluspass => serializer.serialize_i32(56),
            Self::UsTxTolltag => serializer.serialize_i32(57),
            Self::UsTxTxtag => serializer.serialize_i32(58),
            Self::UsTxXpressCard => serializer.serialize_i32(59),
            Self::UsUtAdamsAveParkwayExpresscard => serializer.serialize_i32(60),
            Self::UsVaEzpassva => serializer.serialize_i32(61),
            Self::UsWaBreezeby => serializer.serialize_i32(17),
            Self::UsWaGoodToGo => serializer.serialize_i32(1),
            Self::UsWvEzpasswv => serializer.serialize_i32(62),
            Self::UsWvMemorialBridgeTickets => serializer.serialize_i32(63),
            Self::UsWvMovPass => serializer.serialize_i32(100),
            Self::UsWvNewellTollBridgeTicket => serializer.serialize_i32(64),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

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

/// This field specifies one of the following assumptions to use when calculating
/// travel time in traffic conditions, shown in the enums below. Depending on the
/// enum chosen, the `duration` field of the TrafficModel response will vary. The
/// value contains the predicted time to destination in traffic, based on
/// historical averages. `TrafficModel` is only available for requests that have
/// set [`RoutingPreference`][google.maps.routing.v2.RoutingPreference] to
/// `TRAFFIC_AWARE_OPTIMAL` and
/// [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode] to `DRIVE`.
///
/// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
/// [google.maps.routing.v2.RoutingPreference]: crate::model::RoutingPreference
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum TrafficModel {
    /// Unused. If specified, will default to `BEST_GUESS`.
    Unspecified,
    /// Indicates that the returned `duration` should be the best
    /// estimate of travel time given what is known about both historical traffic
    /// conditions and live traffic. Live traffic becomes more important the closer
    /// the `departure_time` is to now.
    BestGuess,
    /// Indicates that the returned duration should be longer than the
    /// actual travel time on most days, though occasional days with particularly
    /// bad traffic conditions may exceed this value.
    Pessimistic,
    /// Indicates that the returned duration should be shorter than the actual
    /// travel time on most days, though occasional days with particularly good
    /// traffic conditions may be faster than this value.
    Optimistic,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [TrafficModel::value] or
    /// [TrafficModel::name].
    UnknownValue(traffic_model::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<i32> for TrafficModel {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::BestGuess,
            2 => Self::Pessimistic,
            3 => Self::Optimistic,
            _ => Self::UnknownValue(traffic_model::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for TrafficModel {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "TRAFFIC_MODEL_UNSPECIFIED" => Self::Unspecified,
            "BEST_GUESS" => Self::BestGuess,
            "PESSIMISTIC" => Self::Pessimistic,
            "OPTIMISTIC" => Self::Optimistic,
            _ => Self::UnknownValue(traffic_model::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

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

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

/// A set of values that specify the unit of measure used in the display.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum Units {
    /// Units of measure not specified. Defaults to the unit of measure inferred
    /// from the request.
    Unspecified,
    /// Metric units of measure.
    Metric,
    /// Imperial (English) units of measure.
    Imperial,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [Units::value] or
    /// [Units::name].
    UnknownValue(units::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<i32> for Units {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::Metric,
            2 => Self::Imperial,
            _ => Self::UnknownValue(units::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for Units {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "UNITS_UNSPECIFIED" => Self::Unspecified,
            "METRIC" => Self::Metric,
            "IMPERIAL" => Self::Imperial,
            _ => Self::UnknownValue(units::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

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

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

/// A set of values describing the vehicle's emission type.
/// Applies only to the `DRIVE`
/// [`RouteTravelMode`][google.maps.routing.v2.RouteTravelMode].
///
/// [google.maps.routing.v2.RouteTravelMode]: crate::model::RouteTravelMode
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum VehicleEmissionType {
    /// No emission type specified. Default to `GASOLINE`.
    Unspecified,
    /// Gasoline/petrol fueled vehicle.
    Gasoline,
    /// Electricity powered vehicle.
    Electric,
    /// Hybrid fuel (such as gasoline + electric) vehicle.
    Hybrid,
    /// Diesel fueled vehicle.
    Diesel,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [VehicleEmissionType::value] or
    /// [VehicleEmissionType::name].
    UnknownValue(vehicle_emission_type::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<i32> for VehicleEmissionType {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::Gasoline,
            2 => Self::Electric,
            3 => Self::Hybrid,
            4 => Self::Diesel,
            _ => Self::UnknownValue(vehicle_emission_type::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for VehicleEmissionType {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "VEHICLE_EMISSION_TYPE_UNSPECIFIED" => Self::Unspecified,
            "GASOLINE" => Self::Gasoline,
            "ELECTRIC" => Self::Electric,
            "HYBRID" => Self::Hybrid,
            "DIESEL" => Self::Diesel,
            _ => Self::UnknownValue(vehicle_emission_type::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

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

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