google-maps-fleetengine-delivery-v1 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(unused_imports)]
use super::*;

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeliveryVehicleAttribute {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __key,
            __value,
            __string_value,
            __bool_value,
            __number_value,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for DeliveryVehicleAttribute")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "key" => Ok(__FieldTag::__key),
                            "value" => Ok(__FieldTag::__value),
                            "stringValue" => Ok(__FieldTag::__string_value),
                            "string_value" => Ok(__FieldTag::__string_value),
                            "boolValue" => Ok(__FieldTag::__bool_value),
                            "bool_value" => Ok(__FieldTag::__bool_value),
                            "numberValue" => Ok(__FieldTag::__number_value),
                            "number_value" => Ok(__FieldTag::__number_value),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::DeliveryVehicleAttribute;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct DeliveryVehicleAttribute")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__key => {
                            if !fields.insert(__FieldTag::__key) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for key",
                                ));
                            }
                            result.key = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__value => {
                            if !fields.insert(__FieldTag::__value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for value",
                                ));
                            }
                            result.value = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__string_value => {
                            if !fields.insert(__FieldTag::__string_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for string_value",
                                ));
                            }
                            if result.delivery_vehicle_attribute_value.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `delivery_vehicle_attribute_value`, a oneof with full ID .maps.fleetengine.delivery.v1.DeliveryVehicleAttribute.string_value, latest field was stringValue",
                                ));
                            }
                            result.delivery_vehicle_attribute_value = std::option::Option::Some(
                                crate::model::delivery_vehicle_attribute::DeliveryVehicleAttributeValue::StringValue(
                                    map.next_value::<std::option::Option<std::string::String>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__bool_value => {
                            if !fields.insert(__FieldTag::__bool_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for bool_value",
                                ));
                            }
                            if result.delivery_vehicle_attribute_value.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `delivery_vehicle_attribute_value`, a oneof with full ID .maps.fleetengine.delivery.v1.DeliveryVehicleAttribute.bool_value, latest field was boolValue",
                                ));
                            }
                            result.delivery_vehicle_attribute_value = std::option::Option::Some(
                                crate::model::delivery_vehicle_attribute::DeliveryVehicleAttributeValue::BoolValue(
                                    map.next_value::<std::option::Option<bool>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__number_value => {
                            if !fields.insert(__FieldTag::__number_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for number_value",
                                ));
                            }
                            struct __With(std::option::Option<f64>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            if result.delivery_vehicle_attribute_value.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `delivery_vehicle_attribute_value`, a oneof with full ID .maps.fleetengine.delivery.v1.DeliveryVehicleAttribute.number_value, latest field was numberValue",
                                ));
                            }
                            result.delivery_vehicle_attribute_value = std::option::Option::Some(
                                crate::model::delivery_vehicle_attribute::DeliveryVehicleAttributeValue::NumberValue(
                                    map.next_value::<__With>()?.0.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeliveryVehicleLocation {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __location,
            __horizontal_accuracy,
            __latlng_accuracy,
            __heading,
            __bearing_accuracy,
            __heading_accuracy,
            __altitude,
            __vertical_accuracy,
            __altitude_accuracy,
            __speed_kmph,
            __speed,
            __speed_accuracy,
            __update_time,
            __server_time,
            __location_sensor,
            __is_road_snapped,
            __is_gps_sensor_enabled,
            __time_since_update,
            __num_stale_updates,
            __raw_location,
            __raw_location_time,
            __raw_location_sensor,
            __raw_location_accuracy,
            __flp_location,
            __flp_update_time,
            __flp_latlng_accuracy_meters,
            __flp_heading_degrees,
            __supplemental_location,
            __supplemental_location_time,
            __supplemental_location_sensor,
            __supplemental_location_accuracy,
            __road_snapped,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for DeliveryVehicleLocation")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "location" => Ok(__FieldTag::__location),
                            "horizontalAccuracy" => Ok(__FieldTag::__horizontal_accuracy),
                            "horizontal_accuracy" => Ok(__FieldTag::__horizontal_accuracy),
                            "latlngAccuracy" => Ok(__FieldTag::__latlng_accuracy),
                            "latlng_accuracy" => Ok(__FieldTag::__latlng_accuracy),
                            "heading" => Ok(__FieldTag::__heading),
                            "bearingAccuracy" => Ok(__FieldTag::__bearing_accuracy),
                            "bearing_accuracy" => Ok(__FieldTag::__bearing_accuracy),
                            "headingAccuracy" => Ok(__FieldTag::__heading_accuracy),
                            "heading_accuracy" => Ok(__FieldTag::__heading_accuracy),
                            "altitude" => Ok(__FieldTag::__altitude),
                            "verticalAccuracy" => Ok(__FieldTag::__vertical_accuracy),
                            "vertical_accuracy" => Ok(__FieldTag::__vertical_accuracy),
                            "altitudeAccuracy" => Ok(__FieldTag::__altitude_accuracy),
                            "altitude_accuracy" => Ok(__FieldTag::__altitude_accuracy),
                            "speedKmph" => Ok(__FieldTag::__speed_kmph),
                            "speed_kmph" => Ok(__FieldTag::__speed_kmph),
                            "speed" => Ok(__FieldTag::__speed),
                            "speedAccuracy" => Ok(__FieldTag::__speed_accuracy),
                            "speed_accuracy" => Ok(__FieldTag::__speed_accuracy),
                            "updateTime" => Ok(__FieldTag::__update_time),
                            "update_time" => Ok(__FieldTag::__update_time),
                            "serverTime" => Ok(__FieldTag::__server_time),
                            "server_time" => Ok(__FieldTag::__server_time),
                            "locationSensor" => Ok(__FieldTag::__location_sensor),
                            "location_sensor" => Ok(__FieldTag::__location_sensor),
                            "isRoadSnapped" => Ok(__FieldTag::__is_road_snapped),
                            "is_road_snapped" => Ok(__FieldTag::__is_road_snapped),
                            "isGpsSensorEnabled" => Ok(__FieldTag::__is_gps_sensor_enabled),
                            "is_gps_sensor_enabled" => Ok(__FieldTag::__is_gps_sensor_enabled),
                            "timeSinceUpdate" => Ok(__FieldTag::__time_since_update),
                            "time_since_update" => Ok(__FieldTag::__time_since_update),
                            "numStaleUpdates" => Ok(__FieldTag::__num_stale_updates),
                            "num_stale_updates" => Ok(__FieldTag::__num_stale_updates),
                            "rawLocation" => Ok(__FieldTag::__raw_location),
                            "raw_location" => Ok(__FieldTag::__raw_location),
                            "rawLocationTime" => Ok(__FieldTag::__raw_location_time),
                            "raw_location_time" => Ok(__FieldTag::__raw_location_time),
                            "rawLocationSensor" => Ok(__FieldTag::__raw_location_sensor),
                            "raw_location_sensor" => Ok(__FieldTag::__raw_location_sensor),
                            "rawLocationAccuracy" => Ok(__FieldTag::__raw_location_accuracy),
                            "raw_location_accuracy" => Ok(__FieldTag::__raw_location_accuracy),
                            "flpLocation" => Ok(__FieldTag::__flp_location),
                            "flp_location" => Ok(__FieldTag::__flp_location),
                            "flpUpdateTime" => Ok(__FieldTag::__flp_update_time),
                            "flp_update_time" => Ok(__FieldTag::__flp_update_time),
                            "flpLatlngAccuracyMeters" => {
                                Ok(__FieldTag::__flp_latlng_accuracy_meters)
                            }
                            "flp_latlng_accuracy_meters" => {
                                Ok(__FieldTag::__flp_latlng_accuracy_meters)
                            }
                            "flpHeadingDegrees" => Ok(__FieldTag::__flp_heading_degrees),
                            "flp_heading_degrees" => Ok(__FieldTag::__flp_heading_degrees),
                            "supplementalLocation" => Ok(__FieldTag::__supplemental_location),
                            "supplemental_location" => Ok(__FieldTag::__supplemental_location),
                            "supplementalLocationTime" => {
                                Ok(__FieldTag::__supplemental_location_time)
                            }
                            "supplemental_location_time" => {
                                Ok(__FieldTag::__supplemental_location_time)
                            }
                            "supplementalLocationSensor" => {
                                Ok(__FieldTag::__supplemental_location_sensor)
                            }
                            "supplemental_location_sensor" => {
                                Ok(__FieldTag::__supplemental_location_sensor)
                            }
                            "supplementalLocationAccuracy" => {
                                Ok(__FieldTag::__supplemental_location_accuracy)
                            }
                            "supplemental_location_accuracy" => {
                                Ok(__FieldTag::__supplemental_location_accuracy)
                            }
                            "roadSnapped" => Ok(__FieldTag::__road_snapped),
                            "road_snapped" => Ok(__FieldTag::__road_snapped),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::DeliveryVehicleLocation;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct DeliveryVehicleLocation")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__location => {
                            if !fields.insert(__FieldTag::__location) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for location",
                                ));
                            }
                            result.location = map.next_value::<std::option::Option<google_cloud_type::model::LatLng>>()?
                                ;
                        }
                        __FieldTag::__horizontal_accuracy => {
                            if !fields.insert(__FieldTag::__horizontal_accuracy) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for horizontal_accuracy",
                                ));
                            }
                            struct __With(std::option::Option<wkt::DoubleValue>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.horizontal_accuracy = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__latlng_accuracy => {
                            if !fields.insert(__FieldTag::__latlng_accuracy) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for latlng_accuracy",
                                ));
                            }
                            struct __With(std::option::Option<wkt::DoubleValue>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.latlng_accuracy = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__heading => {
                            if !fields.insert(__FieldTag::__heading) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for heading",
                                ));
                            }
                            struct __With(std::option::Option<wkt::Int32Value>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.heading = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__bearing_accuracy => {
                            if !fields.insert(__FieldTag::__bearing_accuracy) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for bearing_accuracy",
                                ));
                            }
                            struct __With(std::option::Option<wkt::DoubleValue>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.bearing_accuracy = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__heading_accuracy => {
                            if !fields.insert(__FieldTag::__heading_accuracy) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for heading_accuracy",
                                ));
                            }
                            struct __With(std::option::Option<wkt::DoubleValue>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.heading_accuracy = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__altitude => {
                            if !fields.insert(__FieldTag::__altitude) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for altitude",
                                ));
                            }
                            struct __With(std::option::Option<wkt::DoubleValue>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.altitude = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__vertical_accuracy => {
                            if !fields.insert(__FieldTag::__vertical_accuracy) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for vertical_accuracy",
                                ));
                            }
                            struct __With(std::option::Option<wkt::DoubleValue>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.vertical_accuracy = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__altitude_accuracy => {
                            if !fields.insert(__FieldTag::__altitude_accuracy) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for altitude_accuracy",
                                ));
                            }
                            struct __With(std::option::Option<wkt::DoubleValue>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.altitude_accuracy = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__speed_kmph => {
                            if !fields.insert(__FieldTag::__speed_kmph) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for speed_kmph",
                                ));
                            }
                            struct __With(std::option::Option<wkt::Int32Value>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.speed_kmph = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__speed => {
                            if !fields.insert(__FieldTag::__speed) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for speed",
                                ));
                            }
                            struct __With(std::option::Option<wkt::DoubleValue>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.speed = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__speed_accuracy => {
                            if !fields.insert(__FieldTag::__speed_accuracy) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for speed_accuracy",
                                ));
                            }
                            struct __With(std::option::Option<wkt::DoubleValue>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.speed_accuracy = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__update_time => {
                            if !fields.insert(__FieldTag::__update_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for update_time",
                                ));
                            }
                            result.update_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__server_time => {
                            if !fields.insert(__FieldTag::__server_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for server_time",
                                ));
                            }
                            result.server_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__location_sensor => {
                            if !fields.insert(__FieldTag::__location_sensor) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for location_sensor",
                                ));
                            }
                            result.location_sensor =
                                map.next_value::<std::option::Option<
                                    crate::model::DeliveryVehicleLocationSensor,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__is_road_snapped => {
                            if !fields.insert(__FieldTag::__is_road_snapped) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for is_road_snapped",
                                ));
                            }
                            result.is_road_snapped =
                                map.next_value::<std::option::Option<wkt::BoolValue>>()?;
                        }
                        __FieldTag::__is_gps_sensor_enabled => {
                            if !fields.insert(__FieldTag::__is_gps_sensor_enabled) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for is_gps_sensor_enabled",
                                ));
                            }
                            result.is_gps_sensor_enabled =
                                map.next_value::<std::option::Option<wkt::BoolValue>>()?;
                        }
                        __FieldTag::__time_since_update => {
                            if !fields.insert(__FieldTag::__time_since_update) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for time_since_update",
                                ));
                            }
                            struct __With(std::option::Option<wkt::Int32Value>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.time_since_update = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__num_stale_updates => {
                            if !fields.insert(__FieldTag::__num_stale_updates) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for num_stale_updates",
                                ));
                            }
                            struct __With(std::option::Option<wkt::Int32Value>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.num_stale_updates = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__raw_location => {
                            if !fields.insert(__FieldTag::__raw_location) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for raw_location",
                                ));
                            }
                            result.raw_location = map.next_value::<std::option::Option<google_cloud_type::model::LatLng>>()?
                                ;
                        }
                        __FieldTag::__raw_location_time => {
                            if !fields.insert(__FieldTag::__raw_location_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for raw_location_time",
                                ));
                            }
                            result.raw_location_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__raw_location_sensor => {
                            if !fields.insert(__FieldTag::__raw_location_sensor) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for raw_location_sensor",
                                ));
                            }
                            result.raw_location_sensor =
                                map.next_value::<std::option::Option<
                                    crate::model::DeliveryVehicleLocationSensor,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__raw_location_accuracy => {
                            if !fields.insert(__FieldTag::__raw_location_accuracy) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for raw_location_accuracy",
                                ));
                            }
                            struct __With(std::option::Option<wkt::DoubleValue>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.raw_location_accuracy = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__flp_location => {
                            if !fields.insert(__FieldTag::__flp_location) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for flp_location",
                                ));
                            }
                            result.flp_location = map.next_value::<std::option::Option<google_cloud_type::model::LatLng>>()?
                                ;
                        }
                        __FieldTag::__flp_update_time => {
                            if !fields.insert(__FieldTag::__flp_update_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for flp_update_time",
                                ));
                            }
                            result.flp_update_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__flp_latlng_accuracy_meters => {
                            if !fields.insert(__FieldTag::__flp_latlng_accuracy_meters) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for flp_latlng_accuracy_meters",
                                ));
                            }
                            struct __With(std::option::Option<wkt::DoubleValue>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.flp_latlng_accuracy_meters = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__flp_heading_degrees => {
                            if !fields.insert(__FieldTag::__flp_heading_degrees) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for flp_heading_degrees",
                                ));
                            }
                            struct __With(std::option::Option<wkt::Int32Value>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.flp_heading_degrees = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__supplemental_location => {
                            if !fields.insert(__FieldTag::__supplemental_location) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for supplemental_location",
                                ));
                            }
                            result.supplemental_location = map.next_value::<std::option::Option<google_cloud_type::model::LatLng>>()?
                                ;
                        }
                        __FieldTag::__supplemental_location_time => {
                            if !fields.insert(__FieldTag::__supplemental_location_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for supplemental_location_time",
                                ));
                            }
                            result.supplemental_location_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__supplemental_location_sensor => {
                            if !fields.insert(__FieldTag::__supplemental_location_sensor) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for supplemental_location_sensor",
                                ));
                            }
                            result.supplemental_location_sensor =
                                map.next_value::<std::option::Option<
                                    crate::model::DeliveryVehicleLocationSensor,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__supplemental_location_accuracy => {
                            if !fields.insert(__FieldTag::__supplemental_location_accuracy) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for supplemental_location_accuracy",
                                ));
                            }
                            struct __With(std::option::Option<wkt::DoubleValue>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.supplemental_location_accuracy = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__road_snapped => {
                            if !fields.insert(__FieldTag::__road_snapped) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for road_snapped",
                                ));
                            }
                            result.road_snapped = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TimeWindow {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __start_time,
            __end_time,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for TimeWindow")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "startTime" => Ok(__FieldTag::__start_time),
                            "start_time" => Ok(__FieldTag::__start_time),
                            "endTime" => Ok(__FieldTag::__end_time),
                            "end_time" => Ok(__FieldTag::__end_time),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::TimeWindow;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct TimeWindow")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__start_time => {
                            if !fields.insert(__FieldTag::__start_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for start_time",
                                ));
                            }
                            result.start_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__end_time => {
                            if !fields.insert(__FieldTag::__end_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for end_time",
                                ));
                            }
                            result.end_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TaskAttribute {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __key,
            __string_value,
            __bool_value,
            __number_value,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for TaskAttribute")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "key" => Ok(__FieldTag::__key),
                            "stringValue" => Ok(__FieldTag::__string_value),
                            "string_value" => Ok(__FieldTag::__string_value),
                            "boolValue" => Ok(__FieldTag::__bool_value),
                            "bool_value" => Ok(__FieldTag::__bool_value),
                            "numberValue" => Ok(__FieldTag::__number_value),
                            "number_value" => Ok(__FieldTag::__number_value),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::TaskAttribute;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct TaskAttribute")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__key => {
                            if !fields.insert(__FieldTag::__key) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for key",
                                ));
                            }
                            result.key = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__string_value => {
                            if !fields.insert(__FieldTag::__string_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for string_value",
                                ));
                            }
                            if result.task_attribute_value.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `task_attribute_value`, a oneof with full ID .maps.fleetengine.delivery.v1.TaskAttribute.string_value, latest field was stringValue",
                                ));
                            }
                            result.task_attribute_value = std::option::Option::Some(
                                crate::model::task_attribute::TaskAttributeValue::StringValue(
                                    map.next_value::<std::option::Option<std::string::String>>()?
                                        .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__bool_value => {
                            if !fields.insert(__FieldTag::__bool_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for bool_value",
                                ));
                            }
                            if result.task_attribute_value.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `task_attribute_value`, a oneof with full ID .maps.fleetengine.delivery.v1.TaskAttribute.bool_value, latest field was boolValue",
                                ));
                            }
                            result.task_attribute_value = std::option::Option::Some(
                                crate::model::task_attribute::TaskAttributeValue::BoolValue(
                                    map.next_value::<std::option::Option<bool>>()?
                                        .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__number_value => {
                            if !fields.insert(__FieldTag::__number_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for number_value",
                                ));
                            }
                            struct __With(std::option::Option<f64>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::F64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            if result.task_attribute_value.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `task_attribute_value`, a oneof with full ID .maps.fleetengine.delivery.v1.TaskAttribute.number_value, latest field was numberValue",
                                ));
                            }
                            result.task_attribute_value = std::option::Option::Some(
                                crate::model::task_attribute::TaskAttributeValue::NumberValue(
                                    map.next_value::<__With>()?.0.unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateDeliveryVehicleRequest {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __header,
            __parent,
            __delivery_vehicle_id,
            __delivery_vehicle,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for CreateDeliveryVehicleRequest")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "header" => Ok(__FieldTag::__header),
                            "parent" => Ok(__FieldTag::__parent),
                            "deliveryVehicleId" => Ok(__FieldTag::__delivery_vehicle_id),
                            "delivery_vehicle_id" => Ok(__FieldTag::__delivery_vehicle_id),
                            "deliveryVehicle" => Ok(__FieldTag::__delivery_vehicle),
                            "delivery_vehicle" => Ok(__FieldTag::__delivery_vehicle),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::CreateDeliveryVehicleRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct CreateDeliveryVehicleRequest")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__header => {
                            if !fields.insert(__FieldTag::__header) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for header",
                                ));
                            }
                            result.header = map.next_value::<std::option::Option<crate::model::DeliveryRequestHeader>>()?
                                ;
                        }
                        __FieldTag::__parent => {
                            if !fields.insert(__FieldTag::__parent) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for parent",
                                ));
                            }
                            result.parent = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__delivery_vehicle_id => {
                            if !fields.insert(__FieldTag::__delivery_vehicle_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for delivery_vehicle_id",
                                ));
                            }
                            result.delivery_vehicle_id = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__delivery_vehicle => {
                            if !fields.insert(__FieldTag::__delivery_vehicle) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for delivery_vehicle",
                                ));
                            }
                            result.delivery_vehicle = map
                                .next_value::<std::option::Option<crate::model::DeliveryVehicle>>(
                                )?;
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetDeliveryVehicleRequest {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __header,
            __name,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for GetDeliveryVehicleRequest")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "header" => Ok(__FieldTag::__header),
                            "name" => Ok(__FieldTag::__name),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::GetDeliveryVehicleRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct GetDeliveryVehicleRequest")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__header => {
                            if !fields.insert(__FieldTag::__header) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for header",
                                ));
                            }
                            result.header = map.next_value::<std::option::Option<crate::model::DeliveryRequestHeader>>()?
                                ;
                        }
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteDeliveryVehicleRequest {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __header,
            __name,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for DeleteDeliveryVehicleRequest")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "header" => Ok(__FieldTag::__header),
                            "name" => Ok(__FieldTag::__name),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::DeleteDeliveryVehicleRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct DeleteDeliveryVehicleRequest")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__header => {
                            if !fields.insert(__FieldTag::__header) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for header",
                                ));
                            }
                            result.header = map.next_value::<std::option::Option<crate::model::DeliveryRequestHeader>>()?
                                ;
                        }
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListDeliveryVehiclesRequest {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __header,
            __parent,
            __page_size,
            __page_token,
            __filter,
            __viewport,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for ListDeliveryVehiclesRequest")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "header" => Ok(__FieldTag::__header),
                            "parent" => Ok(__FieldTag::__parent),
                            "pageSize" => Ok(__FieldTag::__page_size),
                            "page_size" => Ok(__FieldTag::__page_size),
                            "pageToken" => Ok(__FieldTag::__page_token),
                            "page_token" => Ok(__FieldTag::__page_token),
                            "filter" => Ok(__FieldTag::__filter),
                            "viewport" => Ok(__FieldTag::__viewport),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::ListDeliveryVehiclesRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ListDeliveryVehiclesRequest")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__header => {
                            if !fields.insert(__FieldTag::__header) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for header",
                                ));
                            }
                            result.header = map.next_value::<std::option::Option<crate::model::DeliveryRequestHeader>>()?
                                ;
                        }
                        __FieldTag::__parent => {
                            if !fields.insert(__FieldTag::__parent) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for parent",
                                ));
                            }
                            result.parent = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__page_size => {
                            if !fields.insert(__FieldTag::__page_size) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for page_size",
                                ));
                            }
                            struct __With(std::option::Option<i32>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__page_token => {
                            if !fields.insert(__FieldTag::__page_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for page_token",
                                ));
                            }
                            result.page_token = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__filter => {
                            if !fields.insert(__FieldTag::__filter) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for filter",
                                ));
                            }
                            result.filter = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__viewport => {
                            if !fields.insert(__FieldTag::__viewport) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for viewport",
                                ));
                            }
                            result.viewport = map.next_value::<std::option::Option<google_geo_type::model::Viewport>>()?
                                ;
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListDeliveryVehiclesResponse {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __delivery_vehicles,
            __next_page_token,
            __total_size,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for ListDeliveryVehiclesResponse")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "deliveryVehicles" => Ok(__FieldTag::__delivery_vehicles),
                            "delivery_vehicles" => Ok(__FieldTag::__delivery_vehicles),
                            "nextPageToken" => Ok(__FieldTag::__next_page_token),
                            "next_page_token" => Ok(__FieldTag::__next_page_token),
                            "totalSize" => Ok(__FieldTag::__total_size),
                            "total_size" => Ok(__FieldTag::__total_size),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::ListDeliveryVehiclesResponse;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ListDeliveryVehiclesResponse")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__delivery_vehicles => {
                            if !fields.insert(__FieldTag::__delivery_vehicles) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for delivery_vehicles",
                                ));
                            }
                            result.delivery_vehicles =
                                map.next_value::<std::option::Option<
                                    std::vec::Vec<crate::model::DeliveryVehicle>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__next_page_token => {
                            if !fields.insert(__FieldTag::__next_page_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for next_page_token",
                                ));
                            }
                            result.next_page_token = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__total_size => {
                            if !fields.insert(__FieldTag::__total_size) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for total_size",
                                ));
                            }
                            struct __With(std::option::Option<i64>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.total_size = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateDeliveryVehicleRequest {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __header,
            __delivery_vehicle,
            __update_mask,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for UpdateDeliveryVehicleRequest")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "header" => Ok(__FieldTag::__header),
                            "deliveryVehicle" => Ok(__FieldTag::__delivery_vehicle),
                            "delivery_vehicle" => Ok(__FieldTag::__delivery_vehicle),
                            "updateMask" => Ok(__FieldTag::__update_mask),
                            "update_mask" => Ok(__FieldTag::__update_mask),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::UpdateDeliveryVehicleRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct UpdateDeliveryVehicleRequest")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__header => {
                            if !fields.insert(__FieldTag::__header) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for header",
                                ));
                            }
                            result.header = map.next_value::<std::option::Option<crate::model::DeliveryRequestHeader>>()?
                                ;
                        }
                        __FieldTag::__delivery_vehicle => {
                            if !fields.insert(__FieldTag::__delivery_vehicle) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for delivery_vehicle",
                                ));
                            }
                            result.delivery_vehicle = map
                                .next_value::<std::option::Option<crate::model::DeliveryVehicle>>(
                                )?;
                        }
                        __FieldTag::__update_mask => {
                            if !fields.insert(__FieldTag::__update_mask) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for update_mask",
                                ));
                            }
                            result.update_mask =
                                map.next_value::<std::option::Option<wkt::FieldMask>>()?;
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchCreateTasksRequest {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __header,
            __parent,
            __requests,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for BatchCreateTasksRequest")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "header" => Ok(__FieldTag::__header),
                            "parent" => Ok(__FieldTag::__parent),
                            "requests" => Ok(__FieldTag::__requests),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::BatchCreateTasksRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct BatchCreateTasksRequest")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__header => {
                            if !fields.insert(__FieldTag::__header) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for header",
                                ));
                            }
                            result.header = map.next_value::<std::option::Option<crate::model::DeliveryRequestHeader>>()?
                                ;
                        }
                        __FieldTag::__parent => {
                            if !fields.insert(__FieldTag::__parent) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for parent",
                                ));
                            }
                            result.parent = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__requests => {
                            if !fields.insert(__FieldTag::__requests) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for requests",
                                ));
                            }
                            result.requests =
                                map.next_value::<std::option::Option<
                                    std::vec::Vec<crate::model::CreateTaskRequest>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::BatchCreateTasksResponse {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __tasks,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for BatchCreateTasksResponse")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "tasks" => Ok(__FieldTag::__tasks),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::BatchCreateTasksResponse;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct BatchCreateTasksResponse")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__tasks => {
                            if !fields.insert(__FieldTag::__tasks) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for tasks",
                                ));
                            }
                            result.tasks = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Task>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::CreateTaskRequest {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __header,
            __parent,
            __task_id,
            __task,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for CreateTaskRequest")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "header" => Ok(__FieldTag::__header),
                            "parent" => Ok(__FieldTag::__parent),
                            "taskId" => Ok(__FieldTag::__task_id),
                            "task_id" => Ok(__FieldTag::__task_id),
                            "task" => Ok(__FieldTag::__task),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::CreateTaskRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct CreateTaskRequest")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__header => {
                            if !fields.insert(__FieldTag::__header) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for header",
                                ));
                            }
                            result.header = map.next_value::<std::option::Option<crate::model::DeliveryRequestHeader>>()?
                                ;
                        }
                        __FieldTag::__parent => {
                            if !fields.insert(__FieldTag::__parent) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for parent",
                                ));
                            }
                            result.parent = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__task_id => {
                            if !fields.insert(__FieldTag::__task_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for task_id",
                                ));
                            }
                            result.task_id = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__task => {
                            if !fields.insert(__FieldTag::__task) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for task",
                                ));
                            }
                            result.task =
                                map.next_value::<std::option::Option<crate::model::Task>>()?;
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetTaskRequest {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __header,
            __name,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for GetTaskRequest")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "header" => Ok(__FieldTag::__header),
                            "name" => Ok(__FieldTag::__name),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::GetTaskRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct GetTaskRequest")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__header => {
                            if !fields.insert(__FieldTag::__header) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for header",
                                ));
                            }
                            result.header = map.next_value::<std::option::Option<crate::model::DeliveryRequestHeader>>()?
                                ;
                        }
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeleteTaskRequest {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __header,
            __name,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for DeleteTaskRequest")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "header" => Ok(__FieldTag::__header),
                            "name" => Ok(__FieldTag::__name),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::DeleteTaskRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct DeleteTaskRequest")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__header => {
                            if !fields.insert(__FieldTag::__header) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for header",
                                ));
                            }
                            result.header = map.next_value::<std::option::Option<crate::model::DeliveryRequestHeader>>()?
                                ;
                        }
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::UpdateTaskRequest {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __header,
            __task,
            __update_mask,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for UpdateTaskRequest")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "header" => Ok(__FieldTag::__header),
                            "task" => Ok(__FieldTag::__task),
                            "updateMask" => Ok(__FieldTag::__update_mask),
                            "update_mask" => Ok(__FieldTag::__update_mask),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::UpdateTaskRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct UpdateTaskRequest")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__header => {
                            if !fields.insert(__FieldTag::__header) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for header",
                                ));
                            }
                            result.header = map.next_value::<std::option::Option<crate::model::DeliveryRequestHeader>>()?
                                ;
                        }
                        __FieldTag::__task => {
                            if !fields.insert(__FieldTag::__task) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for task",
                                ));
                            }
                            result.task =
                                map.next_value::<std::option::Option<crate::model::Task>>()?;
                        }
                        __FieldTag::__update_mask => {
                            if !fields.insert(__FieldTag::__update_mask) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for update_mask",
                                ));
                            }
                            result.update_mask =
                                map.next_value::<std::option::Option<wkt::FieldMask>>()?;
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListTasksRequest {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __header,
            __parent,
            __page_size,
            __page_token,
            __filter,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for ListTasksRequest")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "header" => Ok(__FieldTag::__header),
                            "parent" => Ok(__FieldTag::__parent),
                            "pageSize" => Ok(__FieldTag::__page_size),
                            "page_size" => Ok(__FieldTag::__page_size),
                            "pageToken" => Ok(__FieldTag::__page_token),
                            "page_token" => Ok(__FieldTag::__page_token),
                            "filter" => Ok(__FieldTag::__filter),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::ListTasksRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ListTasksRequest")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__header => {
                            if !fields.insert(__FieldTag::__header) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for header",
                                ));
                            }
                            result.header = map.next_value::<std::option::Option<crate::model::DeliveryRequestHeader>>()?
                                ;
                        }
                        __FieldTag::__parent => {
                            if !fields.insert(__FieldTag::__parent) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for parent",
                                ));
                            }
                            result.parent = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__page_size => {
                            if !fields.insert(__FieldTag::__page_size) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for page_size",
                                ));
                            }
                            struct __With(std::option::Option<i32>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.page_size = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__page_token => {
                            if !fields.insert(__FieldTag::__page_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for page_token",
                                ));
                            }
                            result.page_token = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__filter => {
                            if !fields.insert(__FieldTag::__filter) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for filter",
                                ));
                            }
                            result.filter = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::ListTasksResponse {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __tasks,
            __next_page_token,
            __total_size,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for ListTasksResponse")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "tasks" => Ok(__FieldTag::__tasks),
                            "nextPageToken" => Ok(__FieldTag::__next_page_token),
                            "next_page_token" => Ok(__FieldTag::__next_page_token),
                            "totalSize" => Ok(__FieldTag::__total_size),
                            "total_size" => Ok(__FieldTag::__total_size),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::ListTasksResponse;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ListTasksResponse")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__tasks => {
                            if !fields.insert(__FieldTag::__tasks) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for tasks",
                                ));
                            }
                            result.tasks = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Task>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__next_page_token => {
                            if !fields.insert(__FieldTag::__next_page_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for next_page_token",
                                ));
                            }
                            result.next_page_token = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__total_size => {
                            if !fields.insert(__FieldTag::__total_size) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for total_size",
                                ));
                            }
                            struct __With(std::option::Option<i64>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.total_size = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::GetTaskTrackingInfoRequest {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __header,
            __name,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for GetTaskTrackingInfoRequest")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "header" => Ok(__FieldTag::__header),
                            "name" => Ok(__FieldTag::__name),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::GetTaskTrackingInfoRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct GetTaskTrackingInfoRequest")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__header => {
                            if !fields.insert(__FieldTag::__header) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for header",
                                ));
                            }
                            result.header = map.next_value::<std::option::Option<crate::model::DeliveryRequestHeader>>()?
                                ;
                        }
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeliveryVehicle {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __last_location,
            __past_locations,
            __navigation_status,
            __current_route_segment,
            __current_route_segment_end_point,
            __remaining_distance_meters,
            __remaining_duration,
            __remaining_vehicle_journey_segments,
            __attributes,
            __type,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for DeliveryVehicle")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "lastLocation" => Ok(__FieldTag::__last_location),
                            "last_location" => Ok(__FieldTag::__last_location),
                            "pastLocations" => Ok(__FieldTag::__past_locations),
                            "past_locations" => Ok(__FieldTag::__past_locations),
                            "navigationStatus" => Ok(__FieldTag::__navigation_status),
                            "navigation_status" => Ok(__FieldTag::__navigation_status),
                            "currentRouteSegment" => Ok(__FieldTag::__current_route_segment),
                            "current_route_segment" => Ok(__FieldTag::__current_route_segment),
                            "currentRouteSegmentEndPoint" => {
                                Ok(__FieldTag::__current_route_segment_end_point)
                            }
                            "current_route_segment_end_point" => {
                                Ok(__FieldTag::__current_route_segment_end_point)
                            }
                            "remainingDistanceMeters" => {
                                Ok(__FieldTag::__remaining_distance_meters)
                            }
                            "remaining_distance_meters" => {
                                Ok(__FieldTag::__remaining_distance_meters)
                            }
                            "remainingDuration" => Ok(__FieldTag::__remaining_duration),
                            "remaining_duration" => Ok(__FieldTag::__remaining_duration),
                            "remainingVehicleJourneySegments" => {
                                Ok(__FieldTag::__remaining_vehicle_journey_segments)
                            }
                            "remaining_vehicle_journey_segments" => {
                                Ok(__FieldTag::__remaining_vehicle_journey_segments)
                            }
                            "attributes" => Ok(__FieldTag::__attributes),
                            "type" => Ok(__FieldTag::__type),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::DeliveryVehicle;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct DeliveryVehicle")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__last_location => {
                            if !fields.insert(__FieldTag::__last_location) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for last_location",
                                ));
                            }
                            result.last_location = map.next_value::<std::option::Option<crate::model::DeliveryVehicleLocation>>()?
                                ;
                        }
                        __FieldTag::__past_locations => {
                            if !fields.insert(__FieldTag::__past_locations) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for past_locations",
                                ));
                            }
                            result.past_locations = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::model::DeliveryVehicleLocation>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__navigation_status => {
                            if !fields.insert(__FieldTag::__navigation_status) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for navigation_status",
                                ));
                            }
                            result.navigation_status =
                                map.next_value::<std::option::Option<
                                    crate::model::DeliveryVehicleNavigationStatus,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__current_route_segment => {
                            if !fields.insert(__FieldTag::__current_route_segment) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for current_route_segment",
                                ));
                            }
                            struct __With(std::option::Option<::bytes::Bytes>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<serde_with::base64::Base64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.current_route_segment =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__current_route_segment_end_point => {
                            if !fields.insert(__FieldTag::__current_route_segment_end_point) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for current_route_segment_end_point",
                                ));
                            }
                            result.current_route_segment_end_point = map.next_value::<std::option::Option<google_cloud_type::model::LatLng>>()?
                                ;
                        }
                        __FieldTag::__remaining_distance_meters => {
                            if !fields.insert(__FieldTag::__remaining_distance_meters) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for remaining_distance_meters",
                                ));
                            }
                            struct __With(std::option::Option<wkt::Int32Value>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.remaining_distance_meters = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__remaining_duration => {
                            if !fields.insert(__FieldTag::__remaining_duration) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for remaining_duration",
                                ));
                            }
                            result.remaining_duration =
                                map.next_value::<std::option::Option<wkt::Duration>>()?;
                        }
                        __FieldTag::__remaining_vehicle_journey_segments => {
                            if !fields.insert(__FieldTag::__remaining_vehicle_journey_segments) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for remaining_vehicle_journey_segments",
                                ));
                            }
                            result.remaining_vehicle_journey_segments = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::model::VehicleJourneySegment>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__attributes => {
                            if !fields.insert(__FieldTag::__attributes) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for attributes",
                                ));
                            }
                            result.attributes = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::model::DeliveryVehicleAttribute>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__type => {
                            if !fields.insert(__FieldTag::__type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for type",
                                ));
                            }
                            result.r#type = map
                                .next_value::<std::option::Option<
                                    crate::model::delivery_vehicle::DeliveryVehicleType,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::LocationInfo {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __point,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for LocationInfo")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "point" => Ok(__FieldTag::__point),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::LocationInfo;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct LocationInfo")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__point => {
                            if !fields.insert(__FieldTag::__point) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for point",
                                ));
                            }
                            result.point = map.next_value::<std::option::Option<google_cloud_type::model::LatLng>>()?
                                ;
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::VehicleJourneySegment {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __stop,
            __driving_distance_meters,
            __driving_duration,
            __path,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for VehicleJourneySegment")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "stop" => Ok(__FieldTag::__stop),
                            "drivingDistanceMeters" => Ok(__FieldTag::__driving_distance_meters),
                            "driving_distance_meters" => Ok(__FieldTag::__driving_distance_meters),
                            "drivingDuration" => Ok(__FieldTag::__driving_duration),
                            "driving_duration" => Ok(__FieldTag::__driving_duration),
                            "path" => Ok(__FieldTag::__path),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::VehicleJourneySegment;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct VehicleJourneySegment")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__stop => {
                            if !fields.insert(__FieldTag::__stop) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for stop",
                                ));
                            }
                            result.stop =
                                map.next_value::<std::option::Option<crate::model::VehicleStop>>()?;
                        }
                        __FieldTag::__driving_distance_meters => {
                            if !fields.insert(__FieldTag::__driving_distance_meters) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for driving_distance_meters",
                                ));
                            }
                            struct __With(std::option::Option<wkt::Int32Value>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.driving_distance_meters = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__driving_duration => {
                            if !fields.insert(__FieldTag::__driving_duration) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for driving_duration",
                                ));
                            }
                            result.driving_duration =
                                map.next_value::<std::option::Option<wkt::Duration>>()?;
                        }
                        __FieldTag::__path => {
                            if !fields.insert(__FieldTag::__path) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for path",
                                ));
                            }
                            result.path = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<google_cloud_type::model::LatLng>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::VehicleStop {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __planned_location,
            __tasks,
            __state,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for VehicleStop")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "plannedLocation" => Ok(__FieldTag::__planned_location),
                            "planned_location" => Ok(__FieldTag::__planned_location),
                            "tasks" => Ok(__FieldTag::__tasks),
                            "state" => Ok(__FieldTag::__state),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::VehicleStop;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct VehicleStop")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__planned_location => {
                            if !fields.insert(__FieldTag::__planned_location) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for planned_location",
                                ));
                            }
                            result.planned_location = map
                                .next_value::<std::option::Option<crate::model::LocationInfo>>()?;
                        }
                        __FieldTag::__tasks => {
                            if !fields.insert(__FieldTag::__tasks) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for tasks",
                                ));
                            }
                            result.tasks = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::model::vehicle_stop::TaskInfo>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__state => {
                            if !fields.insert(__FieldTag::__state) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for state",
                                ));
                            }
                            result.state = map.next_value::<std::option::Option<crate::model::vehicle_stop::State>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::vehicle_stop::TaskInfo {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __task_id,
            __task_duration,
            __target_time_window,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for TaskInfo")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "taskId" => Ok(__FieldTag::__task_id),
                            "task_id" => Ok(__FieldTag::__task_id),
                            "taskDuration" => Ok(__FieldTag::__task_duration),
                            "task_duration" => Ok(__FieldTag::__task_duration),
                            "targetTimeWindow" => Ok(__FieldTag::__target_time_window),
                            "target_time_window" => Ok(__FieldTag::__target_time_window),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::vehicle_stop::TaskInfo;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct TaskInfo")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__task_id => {
                            if !fields.insert(__FieldTag::__task_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for task_id",
                                ));
                            }
                            result.task_id = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__task_duration => {
                            if !fields.insert(__FieldTag::__task_duration) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for task_duration",
                                ));
                            }
                            result.task_duration =
                                map.next_value::<std::option::Option<wkt::Duration>>()?;
                        }
                        __FieldTag::__target_time_window => {
                            if !fields.insert(__FieldTag::__target_time_window) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for target_time_window",
                                ));
                            }
                            result.target_time_window =
                                map.next_value::<std::option::Option<crate::model::TimeWindow>>()?;
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::DeliveryRequestHeader {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __language_code,
            __region_code,
            __sdk_version,
            __os_version,
            __device_model,
            __sdk_type,
            __maps_sdk_version,
            __nav_sdk_version,
            __platform,
            __manufacturer,
            __android_api_level,
            __trace_id,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for DeliveryRequestHeader")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "languageCode" => Ok(__FieldTag::__language_code),
                            "language_code" => Ok(__FieldTag::__language_code),
                            "regionCode" => Ok(__FieldTag::__region_code),
                            "region_code" => Ok(__FieldTag::__region_code),
                            "sdkVersion" => Ok(__FieldTag::__sdk_version),
                            "sdk_version" => Ok(__FieldTag::__sdk_version),
                            "osVersion" => Ok(__FieldTag::__os_version),
                            "os_version" => Ok(__FieldTag::__os_version),
                            "deviceModel" => Ok(__FieldTag::__device_model),
                            "device_model" => Ok(__FieldTag::__device_model),
                            "sdkType" => Ok(__FieldTag::__sdk_type),
                            "sdk_type" => Ok(__FieldTag::__sdk_type),
                            "mapsSdkVersion" => Ok(__FieldTag::__maps_sdk_version),
                            "maps_sdk_version" => Ok(__FieldTag::__maps_sdk_version),
                            "navSdkVersion" => Ok(__FieldTag::__nav_sdk_version),
                            "nav_sdk_version" => Ok(__FieldTag::__nav_sdk_version),
                            "platform" => Ok(__FieldTag::__platform),
                            "manufacturer" => Ok(__FieldTag::__manufacturer),
                            "androidApiLevel" => Ok(__FieldTag::__android_api_level),
                            "android_api_level" => Ok(__FieldTag::__android_api_level),
                            "traceId" => Ok(__FieldTag::__trace_id),
                            "trace_id" => Ok(__FieldTag::__trace_id),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::DeliveryRequestHeader;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct DeliveryRequestHeader")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__language_code => {
                            if !fields.insert(__FieldTag::__language_code) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for language_code",
                                ));
                            }
                            result.language_code = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__region_code => {
                            if !fields.insert(__FieldTag::__region_code) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for region_code",
                                ));
                            }
                            result.region_code = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__sdk_version => {
                            if !fields.insert(__FieldTag::__sdk_version) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for sdk_version",
                                ));
                            }
                            result.sdk_version = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__os_version => {
                            if !fields.insert(__FieldTag::__os_version) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for os_version",
                                ));
                            }
                            result.os_version = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__device_model => {
                            if !fields.insert(__FieldTag::__device_model) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for device_model",
                                ));
                            }
                            result.device_model = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__sdk_type => {
                            if !fields.insert(__FieldTag::__sdk_type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for sdk_type",
                                ));
                            }
                            result.sdk_type =
                                map.next_value::<std::option::Option<
                                    crate::model::delivery_request_header::SdkType,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__maps_sdk_version => {
                            if !fields.insert(__FieldTag::__maps_sdk_version) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for maps_sdk_version",
                                ));
                            }
                            result.maps_sdk_version = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__nav_sdk_version => {
                            if !fields.insert(__FieldTag::__nav_sdk_version) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for nav_sdk_version",
                                ));
                            }
                            result.nav_sdk_version = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__platform => {
                            if !fields.insert(__FieldTag::__platform) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for platform",
                                ));
                            }
                            result.platform = map
                                .next_value::<std::option::Option<
                                    crate::model::delivery_request_header::Platform,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__manufacturer => {
                            if !fields.insert(__FieldTag::__manufacturer) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for manufacturer",
                                ));
                            }
                            result.manufacturer = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__android_api_level => {
                            if !fields.insert(__FieldTag::__android_api_level) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for android_api_level",
                                ));
                            }
                            struct __With(std::option::Option<i32>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.android_api_level =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__trace_id => {
                            if !fields.insert(__FieldTag::__trace_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for trace_id",
                                ));
                            }
                            result.trace_id = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TaskTrackingInfo {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __tracking_id,
            __vehicle_location,
            __route_polyline_points,
            __remaining_stop_count,
            __remaining_driving_distance_meters,
            __estimated_arrival_time,
            __estimated_task_completion_time,
            __state,
            __task_outcome,
            __task_outcome_time,
            __planned_location,
            __target_time_window,
            __attributes,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for TaskTrackingInfo")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "trackingId" => Ok(__FieldTag::__tracking_id),
                            "tracking_id" => Ok(__FieldTag::__tracking_id),
                            "vehicleLocation" => Ok(__FieldTag::__vehicle_location),
                            "vehicle_location" => Ok(__FieldTag::__vehicle_location),
                            "routePolylinePoints" => Ok(__FieldTag::__route_polyline_points),
                            "route_polyline_points" => Ok(__FieldTag::__route_polyline_points),
                            "remainingStopCount" => Ok(__FieldTag::__remaining_stop_count),
                            "remaining_stop_count" => Ok(__FieldTag::__remaining_stop_count),
                            "remainingDrivingDistanceMeters" => {
                                Ok(__FieldTag::__remaining_driving_distance_meters)
                            }
                            "remaining_driving_distance_meters" => {
                                Ok(__FieldTag::__remaining_driving_distance_meters)
                            }
                            "estimatedArrivalTime" => Ok(__FieldTag::__estimated_arrival_time),
                            "estimated_arrival_time" => Ok(__FieldTag::__estimated_arrival_time),
                            "estimatedTaskCompletionTime" => {
                                Ok(__FieldTag::__estimated_task_completion_time)
                            }
                            "estimated_task_completion_time" => {
                                Ok(__FieldTag::__estimated_task_completion_time)
                            }
                            "state" => Ok(__FieldTag::__state),
                            "taskOutcome" => Ok(__FieldTag::__task_outcome),
                            "task_outcome" => Ok(__FieldTag::__task_outcome),
                            "taskOutcomeTime" => Ok(__FieldTag::__task_outcome_time),
                            "task_outcome_time" => Ok(__FieldTag::__task_outcome_time),
                            "plannedLocation" => Ok(__FieldTag::__planned_location),
                            "planned_location" => Ok(__FieldTag::__planned_location),
                            "targetTimeWindow" => Ok(__FieldTag::__target_time_window),
                            "target_time_window" => Ok(__FieldTag::__target_time_window),
                            "attributes" => Ok(__FieldTag::__attributes),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::TaskTrackingInfo;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct TaskTrackingInfo")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__tracking_id => {
                            if !fields.insert(__FieldTag::__tracking_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for tracking_id",
                                ));
                            }
                            result.tracking_id = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__vehicle_location => {
                            if !fields.insert(__FieldTag::__vehicle_location) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for vehicle_location",
                                ));
                            }
                            result.vehicle_location = map.next_value::<std::option::Option<crate::model::DeliveryVehicleLocation>>()?
                                ;
                        }
                        __FieldTag::__route_polyline_points => {
                            if !fields.insert(__FieldTag::__route_polyline_points) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for route_polyline_points",
                                ));
                            }
                            result.route_polyline_points = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<google_cloud_type::model::LatLng>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__remaining_stop_count => {
                            if !fields.insert(__FieldTag::__remaining_stop_count) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for remaining_stop_count",
                                ));
                            }
                            struct __With(std::option::Option<wkt::Int32Value>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.remaining_stop_count = map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__remaining_driving_distance_meters => {
                            if !fields.insert(__FieldTag::__remaining_driving_distance_meters) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for remaining_driving_distance_meters",
                                ));
                            }
                            struct __With(std::option::Option<wkt::Int32Value>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.remaining_driving_distance_meters =
                                map.next_value::<__With>()?.0;
                        }
                        __FieldTag::__estimated_arrival_time => {
                            if !fields.insert(__FieldTag::__estimated_arrival_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for estimated_arrival_time",
                                ));
                            }
                            result.estimated_arrival_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__estimated_task_completion_time => {
                            if !fields.insert(__FieldTag::__estimated_task_completion_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for estimated_task_completion_time",
                                ));
                            }
                            result.estimated_task_completion_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__state => {
                            if !fields.insert(__FieldTag::__state) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for state",
                                ));
                            }
                            result.state = map
                                .next_value::<std::option::Option<crate::model::task::State>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__task_outcome => {
                            if !fields.insert(__FieldTag::__task_outcome) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for task_outcome",
                                ));
                            }
                            result.task_outcome = map
                                .next_value::<std::option::Option<crate::model::task::TaskOutcome>>(
                                )?
                                .unwrap_or_default();
                        }
                        __FieldTag::__task_outcome_time => {
                            if !fields.insert(__FieldTag::__task_outcome_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for task_outcome_time",
                                ));
                            }
                            result.task_outcome_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__planned_location => {
                            if !fields.insert(__FieldTag::__planned_location) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for planned_location",
                                ));
                            }
                            result.planned_location = map
                                .next_value::<std::option::Option<crate::model::LocationInfo>>()?;
                        }
                        __FieldTag::__target_time_window => {
                            if !fields.insert(__FieldTag::__target_time_window) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for target_time_window",
                                ));
                            }
                            result.target_time_window =
                                map.next_value::<std::option::Option<crate::model::TimeWindow>>()?;
                        }
                        __FieldTag::__attributes => {
                            if !fields.insert(__FieldTag::__attributes) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for attributes",
                                ));
                            }
                            result.attributes = map.next_value::<std::option::Option<std::vec::Vec<crate::model::TaskAttribute>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::Task {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __name,
            __type,
            __state,
            __task_outcome,
            __task_outcome_time,
            __task_outcome_location,
            __task_outcome_location_source,
            __tracking_id,
            __delivery_vehicle_id,
            __planned_location,
            __task_duration,
            __target_time_window,
            __journey_sharing_info,
            __task_tracking_view_config,
            __attributes,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for Task")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "name" => Ok(__FieldTag::__name),
                            "type" => Ok(__FieldTag::__type),
                            "state" => Ok(__FieldTag::__state),
                            "taskOutcome" => Ok(__FieldTag::__task_outcome),
                            "task_outcome" => Ok(__FieldTag::__task_outcome),
                            "taskOutcomeTime" => Ok(__FieldTag::__task_outcome_time),
                            "task_outcome_time" => Ok(__FieldTag::__task_outcome_time),
                            "taskOutcomeLocation" => Ok(__FieldTag::__task_outcome_location),
                            "task_outcome_location" => Ok(__FieldTag::__task_outcome_location),
                            "taskOutcomeLocationSource" => {
                                Ok(__FieldTag::__task_outcome_location_source)
                            }
                            "task_outcome_location_source" => {
                                Ok(__FieldTag::__task_outcome_location_source)
                            }
                            "trackingId" => Ok(__FieldTag::__tracking_id),
                            "tracking_id" => Ok(__FieldTag::__tracking_id),
                            "deliveryVehicleId" => Ok(__FieldTag::__delivery_vehicle_id),
                            "delivery_vehicle_id" => Ok(__FieldTag::__delivery_vehicle_id),
                            "plannedLocation" => Ok(__FieldTag::__planned_location),
                            "planned_location" => Ok(__FieldTag::__planned_location),
                            "taskDuration" => Ok(__FieldTag::__task_duration),
                            "task_duration" => Ok(__FieldTag::__task_duration),
                            "targetTimeWindow" => Ok(__FieldTag::__target_time_window),
                            "target_time_window" => Ok(__FieldTag::__target_time_window),
                            "journeySharingInfo" => Ok(__FieldTag::__journey_sharing_info),
                            "journey_sharing_info" => Ok(__FieldTag::__journey_sharing_info),
                            "taskTrackingViewConfig" => Ok(__FieldTag::__task_tracking_view_config),
                            "task_tracking_view_config" => {
                                Ok(__FieldTag::__task_tracking_view_config)
                            }
                            "attributes" => Ok(__FieldTag::__attributes),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::Task;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Task")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__name => {
                            if !fields.insert(__FieldTag::__name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for name",
                                ));
                            }
                            result.name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__type => {
                            if !fields.insert(__FieldTag::__type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for type",
                                ));
                            }
                            result.r#type = map
                                .next_value::<std::option::Option<crate::model::task::Type>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__state => {
                            if !fields.insert(__FieldTag::__state) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for state",
                                ));
                            }
                            result.state = map
                                .next_value::<std::option::Option<crate::model::task::State>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__task_outcome => {
                            if !fields.insert(__FieldTag::__task_outcome) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for task_outcome",
                                ));
                            }
                            result.task_outcome = map
                                .next_value::<std::option::Option<crate::model::task::TaskOutcome>>(
                                )?
                                .unwrap_or_default();
                        }
                        __FieldTag::__task_outcome_time => {
                            if !fields.insert(__FieldTag::__task_outcome_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for task_outcome_time",
                                ));
                            }
                            result.task_outcome_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__task_outcome_location => {
                            if !fields.insert(__FieldTag::__task_outcome_location) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for task_outcome_location",
                                ));
                            }
                            result.task_outcome_location = map
                                .next_value::<std::option::Option<crate::model::LocationInfo>>()?;
                        }
                        __FieldTag::__task_outcome_location_source => {
                            if !fields.insert(__FieldTag::__task_outcome_location_source) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for task_outcome_location_source",
                                ));
                            }
                            result.task_outcome_location_source =
                                map.next_value::<std::option::Option<
                                    crate::model::task::TaskOutcomeLocationSource,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__tracking_id => {
                            if !fields.insert(__FieldTag::__tracking_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for tracking_id",
                                ));
                            }
                            result.tracking_id = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__delivery_vehicle_id => {
                            if !fields.insert(__FieldTag::__delivery_vehicle_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for delivery_vehicle_id",
                                ));
                            }
                            result.delivery_vehicle_id = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__planned_location => {
                            if !fields.insert(__FieldTag::__planned_location) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for planned_location",
                                ));
                            }
                            result.planned_location = map
                                .next_value::<std::option::Option<crate::model::LocationInfo>>()?;
                        }
                        __FieldTag::__task_duration => {
                            if !fields.insert(__FieldTag::__task_duration) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for task_duration",
                                ));
                            }
                            result.task_duration =
                                map.next_value::<std::option::Option<wkt::Duration>>()?;
                        }
                        __FieldTag::__target_time_window => {
                            if !fields.insert(__FieldTag::__target_time_window) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for target_time_window",
                                ));
                            }
                            result.target_time_window =
                                map.next_value::<std::option::Option<crate::model::TimeWindow>>()?;
                        }
                        __FieldTag::__journey_sharing_info => {
                            if !fields.insert(__FieldTag::__journey_sharing_info) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for journey_sharing_info",
                                ));
                            }
                            result.journey_sharing_info = map.next_value::<std::option::Option<crate::model::task::JourneySharingInfo>>()?
                                ;
                        }
                        __FieldTag::__task_tracking_view_config => {
                            if !fields.insert(__FieldTag::__task_tracking_view_config) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for task_tracking_view_config",
                                ));
                            }
                            result.task_tracking_view_config = map.next_value::<std::option::Option<crate::model::TaskTrackingViewConfig>>()?
                                ;
                        }
                        __FieldTag::__attributes => {
                            if !fields.insert(__FieldTag::__attributes) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for attributes",
                                ));
                            }
                            result.attributes = map.next_value::<std::option::Option<std::vec::Vec<crate::model::TaskAttribute>>>()?.unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::task::JourneySharingInfo {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __remaining_vehicle_journey_segments,
            __last_location,
            __last_location_snappable,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for JourneySharingInfo")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "remainingVehicleJourneySegments" => {
                                Ok(__FieldTag::__remaining_vehicle_journey_segments)
                            }
                            "remaining_vehicle_journey_segments" => {
                                Ok(__FieldTag::__remaining_vehicle_journey_segments)
                            }
                            "lastLocation" => Ok(__FieldTag::__last_location),
                            "last_location" => Ok(__FieldTag::__last_location),
                            "lastLocationSnappable" => Ok(__FieldTag::__last_location_snappable),
                            "last_location_snappable" => Ok(__FieldTag::__last_location_snappable),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::task::JourneySharingInfo;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct JourneySharingInfo")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__remaining_vehicle_journey_segments => {
                            if !fields.insert(__FieldTag::__remaining_vehicle_journey_segments) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for remaining_vehicle_journey_segments",
                                ));
                            }
                            result.remaining_vehicle_journey_segments = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::model::VehicleJourneySegment>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__last_location => {
                            if !fields.insert(__FieldTag::__last_location) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for last_location",
                                ));
                            }
                            result.last_location = map.next_value::<std::option::Option<crate::model::DeliveryVehicleLocation>>()?
                                ;
                        }
                        __FieldTag::__last_location_snappable => {
                            if !fields.insert(__FieldTag::__last_location_snappable) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for last_location_snappable",
                                ));
                            }
                            result.last_location_snappable = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::TaskTrackingViewConfig {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __route_polyline_points_visibility,
            __estimated_arrival_time_visibility,
            __estimated_task_completion_time_visibility,
            __remaining_driving_distance_visibility,
            __remaining_stop_count_visibility,
            __vehicle_location_visibility,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for TaskTrackingViewConfig")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "routePolylinePointsVisibility" => {
                                Ok(__FieldTag::__route_polyline_points_visibility)
                            }
                            "route_polyline_points_visibility" => {
                                Ok(__FieldTag::__route_polyline_points_visibility)
                            }
                            "estimatedArrivalTimeVisibility" => {
                                Ok(__FieldTag::__estimated_arrival_time_visibility)
                            }
                            "estimated_arrival_time_visibility" => {
                                Ok(__FieldTag::__estimated_arrival_time_visibility)
                            }
                            "estimatedTaskCompletionTimeVisibility" => {
                                Ok(__FieldTag::__estimated_task_completion_time_visibility)
                            }
                            "estimated_task_completion_time_visibility" => {
                                Ok(__FieldTag::__estimated_task_completion_time_visibility)
                            }
                            "remainingDrivingDistanceVisibility" => {
                                Ok(__FieldTag::__remaining_driving_distance_visibility)
                            }
                            "remaining_driving_distance_visibility" => {
                                Ok(__FieldTag::__remaining_driving_distance_visibility)
                            }
                            "remainingStopCountVisibility" => {
                                Ok(__FieldTag::__remaining_stop_count_visibility)
                            }
                            "remaining_stop_count_visibility" => {
                                Ok(__FieldTag::__remaining_stop_count_visibility)
                            }
                            "vehicleLocationVisibility" => {
                                Ok(__FieldTag::__vehicle_location_visibility)
                            }
                            "vehicle_location_visibility" => {
                                Ok(__FieldTag::__vehicle_location_visibility)
                            }
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::TaskTrackingViewConfig;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct TaskTrackingViewConfig")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__route_polyline_points_visibility => {
                            if !fields.insert(__FieldTag::__route_polyline_points_visibility) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for route_polyline_points_visibility",
                                ));
                            }
                            result.route_polyline_points_visibility = map
                                .next_value::<std::option::Option<
                                    crate::model::task_tracking_view_config::VisibilityOption,
                                >>()?;
                        }
                        __FieldTag::__estimated_arrival_time_visibility => {
                            if !fields.insert(__FieldTag::__estimated_arrival_time_visibility) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for estimated_arrival_time_visibility",
                                ));
                            }
                            result.estimated_arrival_time_visibility = map
                                .next_value::<std::option::Option<
                                    crate::model::task_tracking_view_config::VisibilityOption,
                                >>()?;
                        }
                        __FieldTag::__estimated_task_completion_time_visibility => {
                            if !fields
                                .insert(__FieldTag::__estimated_task_completion_time_visibility)
                            {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for estimated_task_completion_time_visibility",
                                ));
                            }
                            result.estimated_task_completion_time_visibility =
                                map.next_value::<std::option::Option<
                                    crate::model::task_tracking_view_config::VisibilityOption,
                                >>()?;
                        }
                        __FieldTag::__remaining_driving_distance_visibility => {
                            if !fields.insert(__FieldTag::__remaining_driving_distance_visibility) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for remaining_driving_distance_visibility",
                                ));
                            }
                            result.remaining_driving_distance_visibility =
                                map.next_value::<std::option::Option<
                                    crate::model::task_tracking_view_config::VisibilityOption,
                                >>()?;
                        }
                        __FieldTag::__remaining_stop_count_visibility => {
                            if !fields.insert(__FieldTag::__remaining_stop_count_visibility) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for remaining_stop_count_visibility",
                                ));
                            }
                            result.remaining_stop_count_visibility = map
                                .next_value::<std::option::Option<
                                    crate::model::task_tracking_view_config::VisibilityOption,
                                >>()?;
                        }
                        __FieldTag::__vehicle_location_visibility => {
                            if !fields.insert(__FieldTag::__vehicle_location_visibility) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for vehicle_location_visibility",
                                ));
                            }
                            result.vehicle_location_visibility = map
                                .next_value::<std::option::Option<
                                    crate::model::task_tracking_view_config::VisibilityOption,
                                >>()?;
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}

#[doc(hidden)]
impl<'de> serde::de::Deserialize<'de> for super::task_tracking_view_config::VisibilityOption {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[allow(non_camel_case_types)]
        #[doc(hidden)]
        #[derive(PartialEq, Eq, Hash)]
        enum __FieldTag {
            __remaining_stop_count_threshold,
            __duration_until_estimated_arrival_time_threshold,
            __remaining_driving_distance_meters_threshold,
            __always,
            __never,
            Unknown(std::string::String),
        }
        impl<'de> serde::de::Deserialize<'de> for __FieldTag {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                struct Visitor;
                impl<'de> serde::de::Visitor<'de> for Visitor {
                    type Value = __FieldTag;
                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                        formatter.write_str("a field name for VisibilityOption")
                    }
                    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
                    where
                        E: serde::de::Error,
                    {
                        use std::result::Result::Ok;
                        use std::string::ToString;
                        match value {
                            "remainingStopCountThreshold" => {
                                Ok(__FieldTag::__remaining_stop_count_threshold)
                            }
                            "remaining_stop_count_threshold" => {
                                Ok(__FieldTag::__remaining_stop_count_threshold)
                            }
                            "durationUntilEstimatedArrivalTimeThreshold" => {
                                Ok(__FieldTag::__duration_until_estimated_arrival_time_threshold)
                            }
                            "duration_until_estimated_arrival_time_threshold" => {
                                Ok(__FieldTag::__duration_until_estimated_arrival_time_threshold)
                            }
                            "remainingDrivingDistanceMetersThreshold" => {
                                Ok(__FieldTag::__remaining_driving_distance_meters_threshold)
                            }
                            "remaining_driving_distance_meters_threshold" => {
                                Ok(__FieldTag::__remaining_driving_distance_meters_threshold)
                            }
                            "always" => Ok(__FieldTag::__always),
                            "never" => Ok(__FieldTag::__never),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::task_tracking_view_config::VisibilityOption;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct VisibilityOption")
            }
            fn visit_map<A>(self, mut map: A) -> std::result::Result<Self::Value, A::Error>
            where
                A: serde::de::MapAccess<'de>,
            {
                #[allow(unused_imports)]
                use serde::de::Error;
                use std::option::Option::Some;
                let mut fields = std::collections::HashSet::new();
                let mut result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __FieldTag::__remaining_stop_count_threshold => {
                            if !fields.insert(__FieldTag::__remaining_stop_count_threshold) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for remaining_stop_count_threshold",
                                ));
                            }
                            struct __With(std::option::Option<i32>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            if result.visibility_option.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `visibility_option`, a oneof with full ID .maps.fleetengine.delivery.v1.TaskTrackingViewConfig.VisibilityOption.remaining_stop_count_threshold, latest field was remainingStopCountThreshold",
                                ));
                            }
                            result.visibility_option = std::option::Option::Some(
                                crate::model::task_tracking_view_config::visibility_option::VisibilityOption::RemainingStopCountThreshold(
                                    map.next_value::<__With>()?.0.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__duration_until_estimated_arrival_time_threshold => {
                            if !fields.insert(
                                __FieldTag::__duration_until_estimated_arrival_time_threshold,
                            ) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for duration_until_estimated_arrival_time_threshold",
                                ));
                            }
                            if result.visibility_option.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `visibility_option`, a oneof with full ID .maps.fleetengine.delivery.v1.TaskTrackingViewConfig.VisibilityOption.duration_until_estimated_arrival_time_threshold, latest field was durationUntilEstimatedArrivalTimeThreshold",
                                ));
                            }
                            result.visibility_option = std::option::Option::Some(
                                crate::model::task_tracking_view_config::visibility_option::VisibilityOption::DurationUntilEstimatedArrivalTimeThreshold(
                                    map.next_value::<std::option::Option<std::boxed::Box<wkt::Duration>>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__remaining_driving_distance_meters_threshold => {
                            if !fields
                                .insert(__FieldTag::__remaining_driving_distance_meters_threshold)
                            {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for remaining_driving_distance_meters_threshold",
                                ));
                            }
                            struct __With(std::option::Option<i32>);
                            impl<'de> serde::de::Deserialize<'de> for __With {
                                fn deserialize<D>(
                                    deserializer: D,
                                ) -> std::result::Result<Self, D::Error>
                                where
                                    D: serde::de::Deserializer<'de>,
                                {
                                    serde_with::As::< std::option::Option<wkt::internal::I32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            if result.visibility_option.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `visibility_option`, a oneof with full ID .maps.fleetengine.delivery.v1.TaskTrackingViewConfig.VisibilityOption.remaining_driving_distance_meters_threshold, latest field was remainingDrivingDistanceMetersThreshold",
                                ));
                            }
                            result.visibility_option = std::option::Option::Some(
                                crate::model::task_tracking_view_config::visibility_option::VisibilityOption::RemainingDrivingDistanceMetersThreshold(
                                    map.next_value::<__With>()?.0.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__always => {
                            if !fields.insert(__FieldTag::__always) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for always",
                                ));
                            }
                            if result.visibility_option.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `visibility_option`, a oneof with full ID .maps.fleetengine.delivery.v1.TaskTrackingViewConfig.VisibilityOption.always, latest field was always",
                                ));
                            }
                            result.visibility_option = std::option::Option::Some(
                                crate::model::task_tracking_view_config::visibility_option::VisibilityOption::Always(
                                    map.next_value::<std::option::Option<bool>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__never => {
                            if !fields.insert(__FieldTag::__never) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for never",
                                ));
                            }
                            if result.visibility_option.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `visibility_option`, a oneof with full ID .maps.fleetengine.delivery.v1.TaskTrackingViewConfig.VisibilityOption.never, latest field was never",
                                ));
                            }
                            result.visibility_option = std::option::Option::Some(
                                crate::model::task_tracking_view_config::visibility_option::VisibilityOption::Never(
                                    map.next_value::<std::option::Option<bool>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::Unknown(key) => {
                            let value = map.next_value::<serde_json::Value>()?;
                            result._unknown_fields.insert(key, value);
                        }
                    }
                }
                std::result::Result::Ok(result)
            }
        }
        deserializer.deserialize_any(Visitor)
    }
}