google-cloud-spanner 0.34.1-preview

// 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::ChangeStreamRecord {
    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 {
            __data_change_record,
            __heartbeat_record,
            __partition_start_record,
            __partition_end_record,
            __partition_event_record,
            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 ChangeStreamRecord")
                    }
                    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 {
                            "dataChangeRecord" => Ok(__FieldTag::__data_change_record),
                            "data_change_record" => Ok(__FieldTag::__data_change_record),
                            "heartbeatRecord" => Ok(__FieldTag::__heartbeat_record),
                            "heartbeat_record" => Ok(__FieldTag::__heartbeat_record),
                            "partitionStartRecord" => Ok(__FieldTag::__partition_start_record),
                            "partition_start_record" => Ok(__FieldTag::__partition_start_record),
                            "partitionEndRecord" => Ok(__FieldTag::__partition_end_record),
                            "partition_end_record" => Ok(__FieldTag::__partition_end_record),
                            "partitionEventRecord" => Ok(__FieldTag::__partition_event_record),
                            "partition_event_record" => Ok(__FieldTag::__partition_event_record),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::ChangeStreamRecord;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ChangeStreamRecord")
            }
            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::__data_change_record => {
                            if !fields.insert(__FieldTag::__data_change_record) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for data_change_record",
                                ));
                            }
                            if result.record.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `record`, a oneof with full ID .google.spanner.v1.ChangeStreamRecord.data_change_record, latest field was dataChangeRecord",
                                ));
                            }
                            result.record = std::option::Option::Some(
                                crate::model::change_stream_record::Record::DataChangeRecord(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<
                                            crate::model::change_stream_record::DataChangeRecord,
                                        >,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__heartbeat_record => {
                            if !fields.insert(__FieldTag::__heartbeat_record) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for heartbeat_record",
                                ));
                            }
                            if result.record.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `record`, a oneof with full ID .google.spanner.v1.ChangeStreamRecord.heartbeat_record, latest field was heartbeatRecord",
                                ));
                            }
                            result.record = std::option::Option::Some(
                                crate::model::change_stream_record::Record::HeartbeatRecord(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<
                                            crate::model::change_stream_record::HeartbeatRecord,
                                        >,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__partition_start_record => {
                            if !fields.insert(__FieldTag::__partition_start_record) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partition_start_record",
                                ));
                            }
                            if result.record.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `record`, a oneof with full ID .google.spanner.v1.ChangeStreamRecord.partition_start_record, latest field was partitionStartRecord",
                                ));
                            }
                            result.record = std::option::Option::Some(
                                crate::model::change_stream_record::Record::PartitionStartRecord(
                                    map.next_value::<std::option::Option<std::boxed::Box<crate::model::change_stream_record::PartitionStartRecord>>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__partition_end_record => {
                            if !fields.insert(__FieldTag::__partition_end_record) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partition_end_record",
                                ));
                            }
                            if result.record.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `record`, a oneof with full ID .google.spanner.v1.ChangeStreamRecord.partition_end_record, latest field was partitionEndRecord",
                                ));
                            }
                            result.record = std::option::Option::Some(
                                crate::model::change_stream_record::Record::PartitionEndRecord(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<
                                            crate::model::change_stream_record::PartitionEndRecord,
                                        >,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__partition_event_record => {
                            if !fields.insert(__FieldTag::__partition_event_record) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partition_event_record",
                                ));
                            }
                            if result.record.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `record`, a oneof with full ID .google.spanner.v1.ChangeStreamRecord.partition_event_record, latest field was partitionEventRecord",
                                ));
                            }
                            result.record = std::option::Option::Some(
                                crate::model::change_stream_record::Record::PartitionEventRecord(
                                    map.next_value::<std::option::Option<std::boxed::Box<crate::model::change_stream_record::PartitionEventRecord>>>()?.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::change_stream_record::DataChangeRecord {
    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 {
            __commit_timestamp,
            __record_sequence,
            __server_transaction_id,
            __is_last_record_in_transaction_in_partition,
            __table,
            __column_metadata,
            __mods,
            __mod_type,
            __value_capture_type,
            __number_of_records_in_transaction,
            __number_of_partitions_in_transaction,
            __transaction_tag,
            __is_system_transaction,
            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 DataChangeRecord")
                    }
                    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 {
                            "commitTimestamp" => Ok(__FieldTag::__commit_timestamp),
                            "commit_timestamp" => Ok(__FieldTag::__commit_timestamp),
                            "recordSequence" => Ok(__FieldTag::__record_sequence),
                            "record_sequence" => Ok(__FieldTag::__record_sequence),
                            "serverTransactionId" => Ok(__FieldTag::__server_transaction_id),
                            "server_transaction_id" => Ok(__FieldTag::__server_transaction_id),
                            "isLastRecordInTransactionInPartition" => {
                                Ok(__FieldTag::__is_last_record_in_transaction_in_partition)
                            }
                            "is_last_record_in_transaction_in_partition" => {
                                Ok(__FieldTag::__is_last_record_in_transaction_in_partition)
                            }
                            "table" => Ok(__FieldTag::__table),
                            "columnMetadata" => Ok(__FieldTag::__column_metadata),
                            "column_metadata" => Ok(__FieldTag::__column_metadata),
                            "mods" => Ok(__FieldTag::__mods),
                            "modType" => Ok(__FieldTag::__mod_type),
                            "mod_type" => Ok(__FieldTag::__mod_type),
                            "valueCaptureType" => Ok(__FieldTag::__value_capture_type),
                            "value_capture_type" => Ok(__FieldTag::__value_capture_type),
                            "numberOfRecordsInTransaction" => {
                                Ok(__FieldTag::__number_of_records_in_transaction)
                            }
                            "number_of_records_in_transaction" => {
                                Ok(__FieldTag::__number_of_records_in_transaction)
                            }
                            "numberOfPartitionsInTransaction" => {
                                Ok(__FieldTag::__number_of_partitions_in_transaction)
                            }
                            "number_of_partitions_in_transaction" => {
                                Ok(__FieldTag::__number_of_partitions_in_transaction)
                            }
                            "transactionTag" => Ok(__FieldTag::__transaction_tag),
                            "transaction_tag" => Ok(__FieldTag::__transaction_tag),
                            "isSystemTransaction" => Ok(__FieldTag::__is_system_transaction),
                            "is_system_transaction" => Ok(__FieldTag::__is_system_transaction),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::change_stream_record::DataChangeRecord;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct DataChangeRecord")
            }
            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::__commit_timestamp => {
                            if !fields.insert(__FieldTag::__commit_timestamp) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for commit_timestamp",
                                ));
                            }
                            result.commit_timestamp =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__record_sequence => {
                            if !fields.insert(__FieldTag::__record_sequence) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for record_sequence",
                                ));
                            }
                            result.record_sequence = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__server_transaction_id => {
                            if !fields.insert(__FieldTag::__server_transaction_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for server_transaction_id",
                                ));
                            }
                            result.server_transaction_id = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__is_last_record_in_transaction_in_partition => {
                            if !fields
                                .insert(__FieldTag::__is_last_record_in_transaction_in_partition)
                            {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for is_last_record_in_transaction_in_partition",
                                ));
                            }
                            result.is_last_record_in_transaction_in_partition = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__table => {
                            if !fields.insert(__FieldTag::__table) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for table",
                                ));
                            }
                            result.table = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__column_metadata => {
                            if !fields.insert(__FieldTag::__column_metadata) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for column_metadata",
                                ));
                            }
                            result.column_metadata = map.next_value::<std::option::Option<std::vec::Vec<crate::model::change_stream_record::data_change_record::ColumnMetadata>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__mods => {
                            if !fields.insert(__FieldTag::__mods) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for mods",
                                ));
                            }
                            result.mods = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<
                                        crate::model::change_stream_record::data_change_record::Mod,
                                    >,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__mod_type => {
                            if !fields.insert(__FieldTag::__mod_type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for mod_type",
                                ));
                            }
                            result.mod_type = map
                                .next_value::<std::option::Option<
                                    crate::model::change_stream_record::data_change_record::ModType,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__value_capture_type => {
                            if !fields.insert(__FieldTag::__value_capture_type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for value_capture_type",
                                ));
                            }
                            result.value_capture_type = map.next_value::<std::option::Option<crate::model::change_stream_record::data_change_record::ValueCaptureType>>()?.unwrap_or_default();
                        }
                        __FieldTag::__number_of_records_in_transaction => {
                            if !fields.insert(__FieldTag::__number_of_records_in_transaction) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for number_of_records_in_transaction",
                                ));
                            }
                            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.number_of_records_in_transaction =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__number_of_partitions_in_transaction => {
                            if !fields.insert(__FieldTag::__number_of_partitions_in_transaction) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for number_of_partitions_in_transaction",
                                ));
                            }
                            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.number_of_partitions_in_transaction =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__transaction_tag => {
                            if !fields.insert(__FieldTag::__transaction_tag) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for transaction_tag",
                                ));
                            }
                            result.transaction_tag = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__is_system_transaction => {
                            if !fields.insert(__FieldTag::__is_system_transaction) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for is_system_transaction",
                                ));
                            }
                            result.is_system_transaction = 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::change_stream_record::data_change_record::ColumnMetadata
{
    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,
            __is_primary_key,
            __ordinal_position,
            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 ColumnMetadata")
                    }
                    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),
                            "isPrimaryKey" => Ok(__FieldTag::__is_primary_key),
                            "is_primary_key" => Ok(__FieldTag::__is_primary_key),
                            "ordinalPosition" => Ok(__FieldTag::__ordinal_position),
                            "ordinal_position" => Ok(__FieldTag::__ordinal_position),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::change_stream_record::data_change_record::ColumnMetadata;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ColumnMetadata")
            }
            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::Type>>()?;
                        }
                        __FieldTag::__is_primary_key => {
                            if !fields.insert(__FieldTag::__is_primary_key) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for is_primary_key",
                                ));
                            }
                            result.is_primary_key = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__ordinal_position => {
                            if !fields.insert(__FieldTag::__ordinal_position) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for ordinal_position",
                                ));
                            }
                            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.ordinal_position =
                                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::change_stream_record::data_change_record::ModValue
{
    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 {
            __column_metadata_index,
            __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 ModValue")
                    }
                    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 {
                            "columnMetadataIndex" => Ok(__FieldTag::__column_metadata_index),
                            "column_metadata_index" => Ok(__FieldTag::__column_metadata_index),
                            "value" => Ok(__FieldTag::__value),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::change_stream_record::data_change_record::ModValue;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ModValue")
            }
            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::__column_metadata_index => {
                            if !fields.insert(__FieldTag::__column_metadata_index) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for column_metadata_index",
                                ));
                            }
                            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.column_metadata_index =
                                map.next_value::<__With>()?.0.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<wkt::Value>>()?
                                .or(Some(wkt::Value::Null));
                        }
                        __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::change_stream_record::data_change_record::Mod {
    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 {
            __keys,
            __old_values,
            __new_values,
            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 Mod")
                    }
                    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 {
                            "keys" => Ok(__FieldTag::__keys),
                            "oldValues" => Ok(__FieldTag::__old_values),
                            "old_values" => Ok(__FieldTag::__old_values),
                            "newValues" => Ok(__FieldTag::__new_values),
                            "new_values" => Ok(__FieldTag::__new_values),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::change_stream_record::data_change_record::Mod;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Mod")
            }
            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::__keys => {
                            if !fields.insert(__FieldTag::__keys) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for keys",
                                ));
                            }
                            result.keys = map.next_value::<std::option::Option<std::vec::Vec<crate::model::change_stream_record::data_change_record::ModValue>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__old_values => {
                            if !fields.insert(__FieldTag::__old_values) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for old_values",
                                ));
                            }
                            result.old_values = map.next_value::<std::option::Option<std::vec::Vec<crate::model::change_stream_record::data_change_record::ModValue>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__new_values => {
                            if !fields.insert(__FieldTag::__new_values) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for new_values",
                                ));
                            }
                            result.new_values = map.next_value::<std::option::Option<std::vec::Vec<crate::model::change_stream_record::data_change_record::ModValue>>>()?.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::change_stream_record::HeartbeatRecord {
    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 {
            __timestamp,
            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 HeartbeatRecord")
                    }
                    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 {
                            "timestamp" => Ok(__FieldTag::__timestamp),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::change_stream_record::HeartbeatRecord;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct HeartbeatRecord")
            }
            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::__timestamp => {
                            if !fields.insert(__FieldTag::__timestamp) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for timestamp",
                                ));
                            }
                            result.timestamp =
                                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::change_stream_record::PartitionStartRecord {
    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_timestamp,
            __record_sequence,
            __partition_tokens,
            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 PartitionStartRecord")
                    }
                    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 {
                            "startTimestamp" => Ok(__FieldTag::__start_timestamp),
                            "start_timestamp" => Ok(__FieldTag::__start_timestamp),
                            "recordSequence" => Ok(__FieldTag::__record_sequence),
                            "record_sequence" => Ok(__FieldTag::__record_sequence),
                            "partitionTokens" => Ok(__FieldTag::__partition_tokens),
                            "partition_tokens" => Ok(__FieldTag::__partition_tokens),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::change_stream_record::PartitionStartRecord;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct PartitionStartRecord")
            }
            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_timestamp => {
                            if !fields.insert(__FieldTag::__start_timestamp) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for start_timestamp",
                                ));
                            }
                            result.start_timestamp =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__record_sequence => {
                            if !fields.insert(__FieldTag::__record_sequence) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for record_sequence",
                                ));
                            }
                            result.record_sequence = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__partition_tokens => {
                            if !fields.insert(__FieldTag::__partition_tokens) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partition_tokens",
                                ));
                            }
                            result.partition_tokens = map.next_value::<std::option::Option<std::vec::Vec<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::change_stream_record::PartitionEndRecord {
    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 {
            __end_timestamp,
            __record_sequence,
            __partition_token,
            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 PartitionEndRecord")
                    }
                    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 {
                            "endTimestamp" => Ok(__FieldTag::__end_timestamp),
                            "end_timestamp" => Ok(__FieldTag::__end_timestamp),
                            "recordSequence" => Ok(__FieldTag::__record_sequence),
                            "record_sequence" => Ok(__FieldTag::__record_sequence),
                            "partitionToken" => Ok(__FieldTag::__partition_token),
                            "partition_token" => Ok(__FieldTag::__partition_token),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::change_stream_record::PartitionEndRecord;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct PartitionEndRecord")
            }
            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::__end_timestamp => {
                            if !fields.insert(__FieldTag::__end_timestamp) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for end_timestamp",
                                ));
                            }
                            result.end_timestamp =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__record_sequence => {
                            if !fields.insert(__FieldTag::__record_sequence) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for record_sequence",
                                ));
                            }
                            result.record_sequence = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__partition_token => {
                            if !fields.insert(__FieldTag::__partition_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partition_token",
                                ));
                            }
                            result.partition_token = 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::change_stream_record::PartitionEventRecord {
    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 {
            __commit_timestamp,
            __record_sequence,
            __partition_token,
            __move_in_events,
            __move_out_events,
            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 PartitionEventRecord")
                    }
                    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 {
                            "commitTimestamp" => Ok(__FieldTag::__commit_timestamp),
                            "commit_timestamp" => Ok(__FieldTag::__commit_timestamp),
                            "recordSequence" => Ok(__FieldTag::__record_sequence),
                            "record_sequence" => Ok(__FieldTag::__record_sequence),
                            "partitionToken" => Ok(__FieldTag::__partition_token),
                            "partition_token" => Ok(__FieldTag::__partition_token),
                            "moveInEvents" => Ok(__FieldTag::__move_in_events),
                            "move_in_events" => Ok(__FieldTag::__move_in_events),
                            "moveOutEvents" => Ok(__FieldTag::__move_out_events),
                            "move_out_events" => Ok(__FieldTag::__move_out_events),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::change_stream_record::PartitionEventRecord;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct PartitionEventRecord")
            }
            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::__commit_timestamp => {
                            if !fields.insert(__FieldTag::__commit_timestamp) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for commit_timestamp",
                                ));
                            }
                            result.commit_timestamp =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__record_sequence => {
                            if !fields.insert(__FieldTag::__record_sequence) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for record_sequence",
                                ));
                            }
                            result.record_sequence = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__partition_token => {
                            if !fields.insert(__FieldTag::__partition_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partition_token",
                                ));
                            }
                            result.partition_token = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__move_in_events => {
                            if !fields.insert(__FieldTag::__move_in_events) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for move_in_events",
                                ));
                            }
                            result.move_in_events = map.next_value::<std::option::Option<std::vec::Vec<crate::model::change_stream_record::partition_event_record::MoveInEvent>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__move_out_events => {
                            if !fields.insert(__FieldTag::__move_out_events) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for move_out_events",
                                ));
                            }
                            result.move_out_events = map.next_value::<std::option::Option<std::vec::Vec<crate::model::change_stream_record::partition_event_record::MoveOutEvent>>>()?.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::change_stream_record::partition_event_record::MoveInEvent
{
    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 {
            __source_partition_token,
            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 MoveInEvent")
                    }
                    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 {
                            "sourcePartitionToken" => Ok(__FieldTag::__source_partition_token),
                            "source_partition_token" => Ok(__FieldTag::__source_partition_token),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::change_stream_record::partition_event_record::MoveInEvent;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct MoveInEvent")
            }
            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::__source_partition_token => {
                            if !fields.insert(__FieldTag::__source_partition_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for source_partition_token",
                                ));
                            }
                            result.source_partition_token = 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::change_stream_record::partition_event_record::MoveOutEvent
{
    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 {
            __destination_partition_token,
            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 MoveOutEvent")
                    }
                    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 {
                            "destinationPartitionToken" => {
                                Ok(__FieldTag::__destination_partition_token)
                            }
                            "destination_partition_token" => {
                                Ok(__FieldTag::__destination_partition_token)
                            }
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::change_stream_record::partition_event_record::MoveOutEvent;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct MoveOutEvent")
            }
            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::__destination_partition_token => {
                            if !fields.insert(__FieldTag::__destination_partition_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for destination_partition_token",
                                ));
                            }
                            result.destination_partition_token = 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::CommitResponse {
    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 {
            __commit_timestamp,
            __commit_stats,
            __precommit_token,
            __snapshot_timestamp,
            __cache_update,
            __isolation_level,
            __read_lock_mode,
            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 CommitResponse")
                    }
                    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 {
                            "commitTimestamp" => Ok(__FieldTag::__commit_timestamp),
                            "commit_timestamp" => Ok(__FieldTag::__commit_timestamp),
                            "commitStats" => Ok(__FieldTag::__commit_stats),
                            "commit_stats" => Ok(__FieldTag::__commit_stats),
                            "precommitToken" => Ok(__FieldTag::__precommit_token),
                            "precommit_token" => Ok(__FieldTag::__precommit_token),
                            "snapshotTimestamp" => Ok(__FieldTag::__snapshot_timestamp),
                            "snapshot_timestamp" => Ok(__FieldTag::__snapshot_timestamp),
                            "cacheUpdate" => Ok(__FieldTag::__cache_update),
                            "cache_update" => Ok(__FieldTag::__cache_update),
                            "isolationLevel" => Ok(__FieldTag::__isolation_level),
                            "isolation_level" => Ok(__FieldTag::__isolation_level),
                            "readLockMode" => Ok(__FieldTag::__read_lock_mode),
                            "read_lock_mode" => Ok(__FieldTag::__read_lock_mode),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::CommitResponse;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct CommitResponse")
            }
            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::__commit_timestamp => {
                            if !fields.insert(__FieldTag::__commit_timestamp) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for commit_timestamp",
                                ));
                            }
                            result.commit_timestamp =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__commit_stats => {
                            if !fields.insert(__FieldTag::__commit_stats) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for commit_stats",
                                ));
                            }
                            result.commit_stats = map.next_value::<std::option::Option<crate::model::commit_response::CommitStats>>()?
                                ;
                        }
                        __FieldTag::__precommit_token => {
                            if !fields.insert(__FieldTag::__precommit_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for precommit_token",
                                ));
                            }
                            if result.multiplexed_session_retry.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `multiplexed_session_retry`, a oneof with full ID .google.spanner.v1.CommitResponse.precommit_token, latest field was precommitToken",
                                ));
                            }
                            result.multiplexed_session_retry = std::option::Option::Some(
                                crate::model::commit_response::MultiplexedSessionRetry::PrecommitToken(
                                    map.next_value::<std::option::Option<std::boxed::Box<crate::model::MultiplexedSessionPrecommitToken>>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__snapshot_timestamp => {
                            if !fields.insert(__FieldTag::__snapshot_timestamp) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for snapshot_timestamp",
                                ));
                            }
                            result.snapshot_timestamp =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__cache_update => {
                            if !fields.insert(__FieldTag::__cache_update) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for cache_update",
                                ));
                            }
                            result.cache_update =
                                map.next_value::<std::option::Option<crate::model::CacheUpdate>>()?;
                        }
                        __FieldTag::__isolation_level => {
                            if !fields.insert(__FieldTag::__isolation_level) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for isolation_level",
                                ));
                            }
                            result.isolation_level = map
                                .next_value::<std::option::Option<
                                    crate::model::transaction_options::IsolationLevel,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__read_lock_mode => {
                            if !fields.insert(__FieldTag::__read_lock_mode) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for read_lock_mode",
                                ));
                            }
                            result.read_lock_mode = map
                                .next_value::<std::option::Option<
                                    crate::model::transaction_options::read_write::ReadLockMode,
                                >>()?
                                .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::commit_response::CommitStats {
    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 {
            __mutation_count,
            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 CommitStats")
                    }
                    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 {
                            "mutationCount" => Ok(__FieldTag::__mutation_count),
                            "mutation_count" => Ok(__FieldTag::__mutation_count),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::commit_response::CommitStats;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct CommitStats")
            }
            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::__mutation_count => {
                            if !fields.insert(__FieldTag::__mutation_count) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for mutation_count",
                                ));
                            }
                            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.mutation_count =
                                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::KeyRange {
    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_closed,
            __start_open,
            __end_closed,
            __end_open,
            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 KeyRange")
                    }
                    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 {
                            "startClosed" => Ok(__FieldTag::__start_closed),
                            "start_closed" => Ok(__FieldTag::__start_closed),
                            "startOpen" => Ok(__FieldTag::__start_open),
                            "start_open" => Ok(__FieldTag::__start_open),
                            "endClosed" => Ok(__FieldTag::__end_closed),
                            "end_closed" => Ok(__FieldTag::__end_closed),
                            "endOpen" => Ok(__FieldTag::__end_open),
                            "end_open" => Ok(__FieldTag::__end_open),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::KeyRange;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct KeyRange")
            }
            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_closed => {
                            if !fields.insert(__FieldTag::__start_closed) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for start_closed",
                                ));
                            }
                            if result.start_key_type.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `start_key_type`, a oneof with full ID .google.spanner.v1.KeyRange.start_closed, latest field was startClosed",
                                ));
                            }
                            result.start_key_type = std::option::Option::Some(
                                crate::model::key_range::StartKeyType::StartClosed(
                                    map.next_value::<std::option::Option<std::boxed::Box<wkt::ListValue>>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__start_open => {
                            if !fields.insert(__FieldTag::__start_open) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for start_open",
                                ));
                            }
                            if result.start_key_type.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `start_key_type`, a oneof with full ID .google.spanner.v1.KeyRange.start_open, latest field was startOpen",
                                ));
                            }
                            result.start_key_type = std::option::Option::Some(
                                crate::model::key_range::StartKeyType::StartOpen(
                                    map.next_value::<std::option::Option<std::boxed::Box<wkt::ListValue>>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__end_closed => {
                            if !fields.insert(__FieldTag::__end_closed) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for end_closed",
                                ));
                            }
                            if result.end_key_type.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `end_key_type`, a oneof with full ID .google.spanner.v1.KeyRange.end_closed, latest field was endClosed",
                                ));
                            }
                            result.end_key_type = std::option::Option::Some(
                                crate::model::key_range::EndKeyType::EndClosed(
                                    map.next_value::<std::option::Option<std::boxed::Box<wkt::ListValue>>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__end_open => {
                            if !fields.insert(__FieldTag::__end_open) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for end_open",
                                ));
                            }
                            if result.end_key_type.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `end_key_type`, a oneof with full ID .google.spanner.v1.KeyRange.end_open, latest field was endOpen",
                                ));
                            }
                            result.end_key_type = std::option::Option::Some(
                                crate::model::key_range::EndKeyType::EndOpen(
                                    map.next_value::<std::option::Option<std::boxed::Box<wkt::ListValue>>>()?.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::KeySet {
    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 {
            __keys,
            __ranges,
            __all,
            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 KeySet")
                    }
                    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 {
                            "keys" => Ok(__FieldTag::__keys),
                            "ranges" => Ok(__FieldTag::__ranges),
                            "all" => Ok(__FieldTag::__all),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::KeySet;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct KeySet")
            }
            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::__keys => {
                            if !fields.insert(__FieldTag::__keys) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for keys",
                                ));
                            }
                            result.keys = map
                                .next_value::<std::option::Option<std::vec::Vec<wkt::ListValue>>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__ranges => {
                            if !fields.insert(__FieldTag::__ranges) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for ranges",
                                ));
                            }
                            result.ranges = map.next_value::<std::option::Option<std::vec::Vec<crate::model::KeyRange>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__all => {
                            if !fields.insert(__FieldTag::__all) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for all",
                                ));
                            }
                            result.all = 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::Range {
    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_key,
            __limit_key,
            __group_uid,
            __split_id,
            __generation,
            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 Range")
                    }
                    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 {
                            "startKey" => Ok(__FieldTag::__start_key),
                            "start_key" => Ok(__FieldTag::__start_key),
                            "limitKey" => Ok(__FieldTag::__limit_key),
                            "limit_key" => Ok(__FieldTag::__limit_key),
                            "groupUid" => Ok(__FieldTag::__group_uid),
                            "group_uid" => Ok(__FieldTag::__group_uid),
                            "splitId" => Ok(__FieldTag::__split_id),
                            "split_id" => Ok(__FieldTag::__split_id),
                            "generation" => Ok(__FieldTag::__generation),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::Range;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Range")
            }
            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_key => {
                            if !fields.insert(__FieldTag::__start_key) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for start_key",
                                ));
                            }
                            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.start_key = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__limit_key => {
                            if !fields.insert(__FieldTag::__limit_key) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for limit_key",
                                ));
                            }
                            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.limit_key = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__group_uid => {
                            if !fields.insert(__FieldTag::__group_uid) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for group_uid",
                                ));
                            }
                            struct __With(std::option::Option<u64>);
                            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::U64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.group_uid = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__split_id => {
                            if !fields.insert(__FieldTag::__split_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for split_id",
                                ));
                            }
                            struct __With(std::option::Option<u64>);
                            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::U64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.split_id = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__generation => {
                            if !fields.insert(__FieldTag::__generation) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for generation",
                                ));
                            }
                            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.generation = 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::Tablet {
    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 {
            __tablet_uid,
            __server_address,
            __location,
            __role,
            __incarnation,
            __distance,
            __skip,
            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 Tablet")
                    }
                    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 {
                            "tabletUid" => Ok(__FieldTag::__tablet_uid),
                            "tablet_uid" => Ok(__FieldTag::__tablet_uid),
                            "serverAddress" => Ok(__FieldTag::__server_address),
                            "server_address" => Ok(__FieldTag::__server_address),
                            "location" => Ok(__FieldTag::__location),
                            "role" => Ok(__FieldTag::__role),
                            "incarnation" => Ok(__FieldTag::__incarnation),
                            "distance" => Ok(__FieldTag::__distance),
                            "skip" => Ok(__FieldTag::__skip),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::Tablet;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Tablet")
            }
            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::__tablet_uid => {
                            if !fields.insert(__FieldTag::__tablet_uid) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for tablet_uid",
                                ));
                            }
                            struct __With(std::option::Option<u64>);
                            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::U64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.tablet_uid = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__server_address => {
                            if !fields.insert(__FieldTag::__server_address) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for server_address",
                                ));
                            }
                            result.server_address = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __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<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__role => {
                            if !fields.insert(__FieldTag::__role) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for role",
                                ));
                            }
                            result.role = map
                                .next_value::<std::option::Option<crate::model::tablet::Role>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__incarnation => {
                            if !fields.insert(__FieldTag::__incarnation) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for incarnation",
                                ));
                            }
                            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.incarnation = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__distance => {
                            if !fields.insert(__FieldTag::__distance) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for distance",
                                ));
                            }
                            struct __With(std::option::Option<u32>);
                            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::U32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.distance = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__skip => {
                            if !fields.insert(__FieldTag::__skip) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for skip",
                                ));
                            }
                            result.skip = 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::Group {
    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 {
            __group_uid,
            __tablets,
            __leader_index,
            __generation,
            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 Group")
                    }
                    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 {
                            "groupUid" => Ok(__FieldTag::__group_uid),
                            "group_uid" => Ok(__FieldTag::__group_uid),
                            "tablets" => Ok(__FieldTag::__tablets),
                            "leaderIndex" => Ok(__FieldTag::__leader_index),
                            "leader_index" => Ok(__FieldTag::__leader_index),
                            "generation" => Ok(__FieldTag::__generation),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::Group;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Group")
            }
            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::__group_uid => {
                            if !fields.insert(__FieldTag::__group_uid) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for group_uid",
                                ));
                            }
                            struct __With(std::option::Option<u64>);
                            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::U64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.group_uid = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__tablets => {
                            if !fields.insert(__FieldTag::__tablets) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for tablets",
                                ));
                            }
                            result.tablets = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Tablet>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__leader_index => {
                            if !fields.insert(__FieldTag::__leader_index) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for leader_index",
                                ));
                            }
                            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.leader_index = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__generation => {
                            if !fields.insert(__FieldTag::__generation) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for generation",
                                ));
                            }
                            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.generation = 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::KeyRecipe {
    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 {
            __table_name,
            __index_name,
            __operation_uid,
            __part,
            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 KeyRecipe")
                    }
                    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 {
                            "tableName" => Ok(__FieldTag::__table_name),
                            "table_name" => Ok(__FieldTag::__table_name),
                            "indexName" => Ok(__FieldTag::__index_name),
                            "index_name" => Ok(__FieldTag::__index_name),
                            "operationUid" => Ok(__FieldTag::__operation_uid),
                            "operation_uid" => Ok(__FieldTag::__operation_uid),
                            "part" => Ok(__FieldTag::__part),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::KeyRecipe;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct KeyRecipe")
            }
            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::__table_name => {
                            if !fields.insert(__FieldTag::__table_name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for table_name",
                                ));
                            }
                            if result.target.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `target`, a oneof with full ID .google.spanner.v1.KeyRecipe.table_name, latest field was tableName",
                                ));
                            }
                            result.target = std::option::Option::Some(
                                crate::model::key_recipe::Target::TableName(
                                    map.next_value::<std::option::Option<std::string::String>>()?
                                        .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__index_name => {
                            if !fields.insert(__FieldTag::__index_name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for index_name",
                                ));
                            }
                            if result.target.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `target`, a oneof with full ID .google.spanner.v1.KeyRecipe.index_name, latest field was indexName",
                                ));
                            }
                            result.target = std::option::Option::Some(
                                crate::model::key_recipe::Target::IndexName(
                                    map.next_value::<std::option::Option<std::string::String>>()?
                                        .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__operation_uid => {
                            if !fields.insert(__FieldTag::__operation_uid) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for operation_uid",
                                ));
                            }
                            struct __With(std::option::Option<u64>);
                            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::U64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            if result.target.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `target`, a oneof with full ID .google.spanner.v1.KeyRecipe.operation_uid, latest field was operationUid",
                                ));
                            }
                            result.target = std::option::Option::Some(
                                crate::model::key_recipe::Target::OperationUid(
                                    map.next_value::<__With>()?.0.unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__part => {
                            if !fields.insert(__FieldTag::__part) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for part",
                                ));
                            }
                            result.part =
                                map.next_value::<std::option::Option<
                                    std::vec::Vec<crate::model::key_recipe::Part>,
                                >>()?
                                .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::key_recipe::Part {
    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 {
            __tag,
            __order,
            __null_order,
            __type,
            __identifier,
            __value,
            __random,
            __struct_identifiers,
            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 Part")
                    }
                    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 {
                            "tag" => Ok(__FieldTag::__tag),
                            "order" => Ok(__FieldTag::__order),
                            "nullOrder" => Ok(__FieldTag::__null_order),
                            "null_order" => Ok(__FieldTag::__null_order),
                            "type" => Ok(__FieldTag::__type),
                            "identifier" => Ok(__FieldTag::__identifier),
                            "value" => Ok(__FieldTag::__value),
                            "random" => Ok(__FieldTag::__random),
                            "structIdentifiers" => Ok(__FieldTag::__struct_identifiers),
                            "struct_identifiers" => Ok(__FieldTag::__struct_identifiers),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::key_recipe::Part;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Part")
            }
            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::__tag => {
                            if !fields.insert(__FieldTag::__tag) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for tag",
                                ));
                            }
                            struct __With(std::option::Option<u32>);
                            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::U32> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.tag = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__order => {
                            if !fields.insert(__FieldTag::__order) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for order",
                                ));
                            }
                            result.order = map.next_value::<std::option::Option<crate::model::key_recipe::part::Order>>()?.unwrap_or_default();
                        }
                        __FieldTag::__null_order => {
                            if !fields.insert(__FieldTag::__null_order) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for null_order",
                                ));
                            }
                            result.null_order = map.next_value::<std::option::Option<crate::model::key_recipe::part::NullOrder>>()?.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::Type>>()?;
                        }
                        __FieldTag::__identifier => {
                            if !fields.insert(__FieldTag::__identifier) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for identifier",
                                ));
                            }
                            if result.value_type.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `value_type`, a oneof with full ID .google.spanner.v1.KeyRecipe.Part.identifier, latest field was identifier",
                                ));
                            }
                            result.value_type = std::option::Option::Some(
                                crate::model::key_recipe::part::ValueType::Identifier(
                                    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",
                                ));
                            }
                            if result.value_type.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `value_type`, a oneof with full ID .google.spanner.v1.KeyRecipe.Part.value, latest field was value",
                                ));
                            }
                            result.value_type = std::option::Option::Some(
                                crate::model::key_recipe::part::ValueType::Value(
                                    map.next_value::<std::option::Option<std::boxed::Box<wkt::Value>>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__random => {
                            if !fields.insert(__FieldTag::__random) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for random",
                                ));
                            }
                            if result.value_type.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `value_type`, a oneof with full ID .google.spanner.v1.KeyRecipe.Part.random, latest field was random",
                                ));
                            }
                            result.value_type = std::option::Option::Some(
                                crate::model::key_recipe::part::ValueType::Random(
                                    map.next_value::<std::option::Option<bool>>()?
                                        .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__struct_identifiers => {
                            if !fields.insert(__FieldTag::__struct_identifiers) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for struct_identifiers",
                                ));
                            }
                            struct __With(std::option::Option<std::vec::Vec<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<std::vec::Vec<wkt::internal::I32>>,
                                    >::deserialize(deserializer)
                                    .map(__With)
                                }
                            }
                            result.struct_identifiers =
                                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::RecipeList {
    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 {
            __schema_generation,
            __recipe,
            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 RecipeList")
                    }
                    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 {
                            "schemaGeneration" => Ok(__FieldTag::__schema_generation),
                            "schema_generation" => Ok(__FieldTag::__schema_generation),
                            "recipe" => Ok(__FieldTag::__recipe),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::RecipeList;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct RecipeList")
            }
            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::__schema_generation => {
                            if !fields.insert(__FieldTag::__schema_generation) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for schema_generation",
                                ));
                            }
                            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.schema_generation =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__recipe => {
                            if !fields.insert(__FieldTag::__recipe) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for recipe",
                                ));
                            }
                            result.recipe = map.next_value::<std::option::Option<std::vec::Vec<crate::model::KeyRecipe>>>()?.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::CacheUpdate {
    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 {
            __database_id,
            __range,
            __group,
            __key_recipes,
            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 CacheUpdate")
                    }
                    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 {
                            "databaseId" => Ok(__FieldTag::__database_id),
                            "database_id" => Ok(__FieldTag::__database_id),
                            "range" => Ok(__FieldTag::__range),
                            "group" => Ok(__FieldTag::__group),
                            "keyRecipes" => Ok(__FieldTag::__key_recipes),
                            "key_recipes" => Ok(__FieldTag::__key_recipes),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::CacheUpdate;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct CacheUpdate")
            }
            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::__database_id => {
                            if !fields.insert(__FieldTag::__database_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for database_id",
                                ));
                            }
                            struct __With(std::option::Option<u64>);
                            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::U64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.database_id = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__range => {
                            if !fields.insert(__FieldTag::__range) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for range",
                                ));
                            }
                            result.range = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Range>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__group => {
                            if !fields.insert(__FieldTag::__group) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for group",
                                ));
                            }
                            result.group = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Group>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__key_recipes => {
                            if !fields.insert(__FieldTag::__key_recipes) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for key_recipes",
                                ));
                            }
                            result.key_recipes =
                                map.next_value::<std::option::Option<crate::model::RecipeList>>()?;
                        }
                        __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::RoutingHint {
    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 {
            __operation_uid,
            __database_id,
            __schema_generation,
            __key,
            __limit_key,
            __group_uid,
            __split_id,
            __tablet_uid,
            __skipped_tablet_uid,
            __client_location,
            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 RoutingHint")
                    }
                    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 {
                            "operationUid" => Ok(__FieldTag::__operation_uid),
                            "operation_uid" => Ok(__FieldTag::__operation_uid),
                            "databaseId" => Ok(__FieldTag::__database_id),
                            "database_id" => Ok(__FieldTag::__database_id),
                            "schemaGeneration" => Ok(__FieldTag::__schema_generation),
                            "schema_generation" => Ok(__FieldTag::__schema_generation),
                            "key" => Ok(__FieldTag::__key),
                            "limitKey" => Ok(__FieldTag::__limit_key),
                            "limit_key" => Ok(__FieldTag::__limit_key),
                            "groupUid" => Ok(__FieldTag::__group_uid),
                            "group_uid" => Ok(__FieldTag::__group_uid),
                            "splitId" => Ok(__FieldTag::__split_id),
                            "split_id" => Ok(__FieldTag::__split_id),
                            "tabletUid" => Ok(__FieldTag::__tablet_uid),
                            "tablet_uid" => Ok(__FieldTag::__tablet_uid),
                            "skippedTabletUid" => Ok(__FieldTag::__skipped_tablet_uid),
                            "skipped_tablet_uid" => Ok(__FieldTag::__skipped_tablet_uid),
                            "clientLocation" => Ok(__FieldTag::__client_location),
                            "client_location" => Ok(__FieldTag::__client_location),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::RoutingHint;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct RoutingHint")
            }
            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::__operation_uid => {
                            if !fields.insert(__FieldTag::__operation_uid) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for operation_uid",
                                ));
                            }
                            struct __With(std::option::Option<u64>);
                            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::U64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.operation_uid =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__database_id => {
                            if !fields.insert(__FieldTag::__database_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for database_id",
                                ));
                            }
                            struct __With(std::option::Option<u64>);
                            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::U64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.database_id = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__schema_generation => {
                            if !fields.insert(__FieldTag::__schema_generation) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for schema_generation",
                                ));
                            }
                            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.schema_generation =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__key => {
                            if !fields.insert(__FieldTag::__key) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for key",
                                ));
                            }
                            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.key = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__limit_key => {
                            if !fields.insert(__FieldTag::__limit_key) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for limit_key",
                                ));
                            }
                            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.limit_key = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__group_uid => {
                            if !fields.insert(__FieldTag::__group_uid) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for group_uid",
                                ));
                            }
                            struct __With(std::option::Option<u64>);
                            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::U64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.group_uid = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__split_id => {
                            if !fields.insert(__FieldTag::__split_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for split_id",
                                ));
                            }
                            struct __With(std::option::Option<u64>);
                            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::U64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.split_id = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__tablet_uid => {
                            if !fields.insert(__FieldTag::__tablet_uid) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for tablet_uid",
                                ));
                            }
                            struct __With(std::option::Option<u64>);
                            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::U64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.tablet_uid = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__skipped_tablet_uid => {
                            if !fields.insert(__FieldTag::__skipped_tablet_uid) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for skipped_tablet_uid",
                                ));
                            }
                            result.skipped_tablet_uid = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::model::routing_hint::SkippedTablet>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__client_location => {
                            if !fields.insert(__FieldTag::__client_location) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for client_location",
                                ));
                            }
                            result.client_location = 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::routing_hint::SkippedTablet {
    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 {
            __tablet_uid,
            __incarnation,
            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 SkippedTablet")
                    }
                    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 {
                            "tabletUid" => Ok(__FieldTag::__tablet_uid),
                            "tablet_uid" => Ok(__FieldTag::__tablet_uid),
                            "incarnation" => Ok(__FieldTag::__incarnation),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::routing_hint::SkippedTablet;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct SkippedTablet")
            }
            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::__tablet_uid => {
                            if !fields.insert(__FieldTag::__tablet_uid) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for tablet_uid",
                                ));
                            }
                            struct __With(std::option::Option<u64>);
                            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::U64> >::deserialize(deserializer).map(__With)
                                }
                            }
                            result.tablet_uid = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__incarnation => {
                            if !fields.insert(__FieldTag::__incarnation) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for incarnation",
                                ));
                            }
                            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.incarnation = 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::Mutation {
    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 {
            __insert,
            __update,
            __insert_or_update,
            __replace,
            __delete,
            __send,
            __ack,
            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 Mutation")
                    }
                    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 {
                            "insert" => Ok(__FieldTag::__insert),
                            "update" => Ok(__FieldTag::__update),
                            "insertOrUpdate" => Ok(__FieldTag::__insert_or_update),
                            "insert_or_update" => Ok(__FieldTag::__insert_or_update),
                            "replace" => Ok(__FieldTag::__replace),
                            "delete" => Ok(__FieldTag::__delete),
                            "send" => Ok(__FieldTag::__send),
                            "ack" => Ok(__FieldTag::__ack),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::Mutation;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Mutation")
            }
            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::__insert => {
                            if !fields.insert(__FieldTag::__insert) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for insert",
                                ));
                            }
                            if result.operation.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `operation`, a oneof with full ID .google.spanner.v1.Mutation.insert, latest field was insert",
                                ));
                            }
                            result.operation = std::option::Option::Some(
                                crate::model::mutation::Operation::Insert(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<crate::model::mutation::Write>,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__update => {
                            if !fields.insert(__FieldTag::__update) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for update",
                                ));
                            }
                            if result.operation.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `operation`, a oneof with full ID .google.spanner.v1.Mutation.update, latest field was update",
                                ));
                            }
                            result.operation = std::option::Option::Some(
                                crate::model::mutation::Operation::Update(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<crate::model::mutation::Write>,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__insert_or_update => {
                            if !fields.insert(__FieldTag::__insert_or_update) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for insert_or_update",
                                ));
                            }
                            if result.operation.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `operation`, a oneof with full ID .google.spanner.v1.Mutation.insert_or_update, latest field was insertOrUpdate",
                                ));
                            }
                            result.operation = std::option::Option::Some(
                                crate::model::mutation::Operation::InsertOrUpdate(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<crate::model::mutation::Write>,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__replace => {
                            if !fields.insert(__FieldTag::__replace) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for replace",
                                ));
                            }
                            if result.operation.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `operation`, a oneof with full ID .google.spanner.v1.Mutation.replace, latest field was replace",
                                ));
                            }
                            result.operation = std::option::Option::Some(
                                crate::model::mutation::Operation::Replace(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<crate::model::mutation::Write>,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__delete => {
                            if !fields.insert(__FieldTag::__delete) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for delete",
                                ));
                            }
                            if result.operation.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `operation`, a oneof with full ID .google.spanner.v1.Mutation.delete, latest field was delete",
                                ));
                            }
                            result.operation = std::option::Option::Some(
                                crate::model::mutation::Operation::Delete(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<crate::model::mutation::Delete>,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__send => {
                            if !fields.insert(__FieldTag::__send) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for send",
                                ));
                            }
                            if result.operation.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `operation`, a oneof with full ID .google.spanner.v1.Mutation.send, latest field was send",
                                ));
                            }
                            result.operation =
                                std::option::Option::Some(crate::model::mutation::Operation::Send(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<crate::model::mutation::Send>,
                                    >>()?
                                    .unwrap_or_default(),
                                ));
                        }
                        __FieldTag::__ack => {
                            if !fields.insert(__FieldTag::__ack) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for ack",
                                ));
                            }
                            if result.operation.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `operation`, a oneof with full ID .google.spanner.v1.Mutation.ack, latest field was ack",
                                ));
                            }
                            result.operation =
                                std::option::Option::Some(crate::model::mutation::Operation::Ack(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<crate::model::mutation::Ack>,
                                    >>()?
                                    .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::mutation::Write {
    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 {
            __table,
            __columns,
            __values,
            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 Write")
                    }
                    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 {
                            "table" => Ok(__FieldTag::__table),
                            "columns" => Ok(__FieldTag::__columns),
                            "values" => Ok(__FieldTag::__values),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::mutation::Write;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Write")
            }
            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::__table => {
                            if !fields.insert(__FieldTag::__table) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for table",
                                ));
                            }
                            result.table = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__columns => {
                            if !fields.insert(__FieldTag::__columns) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for columns",
                                ));
                            }
                            result.columns = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__values => {
                            if !fields.insert(__FieldTag::__values) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for values",
                                ));
                            }
                            result.values = map
                                .next_value::<std::option::Option<std::vec::Vec<wkt::ListValue>>>()?
                                .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::mutation::Delete {
    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 {
            __table,
            __key_set,
            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 Delete")
                    }
                    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 {
                            "table" => Ok(__FieldTag::__table),
                            "keySet" => Ok(__FieldTag::__key_set),
                            "key_set" => Ok(__FieldTag::__key_set),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::mutation::Delete;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Delete")
            }
            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::__table => {
                            if !fields.insert(__FieldTag::__table) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for table",
                                ));
                            }
                            result.table = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__key_set => {
                            if !fields.insert(__FieldTag::__key_set) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for key_set",
                                ));
                            }
                            result.key_set =
                                map.next_value::<std::option::Option<crate::model::KeySet>>()?;
                        }
                        __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::mutation::Send {
    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 {
            __queue,
            __key,
            __deliver_time,
            __payload,
            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 Send")
                    }
                    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 {
                            "queue" => Ok(__FieldTag::__queue),
                            "key" => Ok(__FieldTag::__key),
                            "deliverTime" => Ok(__FieldTag::__deliver_time),
                            "deliver_time" => Ok(__FieldTag::__deliver_time),
                            "payload" => Ok(__FieldTag::__payload),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::mutation::Send;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Send")
            }
            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::__queue => {
                            if !fields.insert(__FieldTag::__queue) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for queue",
                                ));
                            }
                            result.queue = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __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<wkt::ListValue>>()?;
                        }
                        __FieldTag::__deliver_time => {
                            if !fields.insert(__FieldTag::__deliver_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for deliver_time",
                                ));
                            }
                            result.deliver_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__payload => {
                            if !fields.insert(__FieldTag::__payload) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for payload",
                                ));
                            }
                            result.payload = map
                                .next_value::<std::option::Option<wkt::Value>>()?
                                .or(Some(wkt::Value::Null));
                        }
                        __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::mutation::Ack {
    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 {
            __queue,
            __key,
            __ignore_not_found,
            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 Ack")
                    }
                    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 {
                            "queue" => Ok(__FieldTag::__queue),
                            "key" => Ok(__FieldTag::__key),
                            "ignoreNotFound" => Ok(__FieldTag::__ignore_not_found),
                            "ignore_not_found" => Ok(__FieldTag::__ignore_not_found),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::mutation::Ack;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Ack")
            }
            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::__queue => {
                            if !fields.insert(__FieldTag::__queue) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for queue",
                                ));
                            }
                            result.queue = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __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<wkt::ListValue>>()?;
                        }
                        __FieldTag::__ignore_not_found => {
                            if !fields.insert(__FieldTag::__ignore_not_found) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for ignore_not_found",
                                ));
                            }
                            result.ignore_not_found = 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::PlanNode {
    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 {
            __index,
            __kind,
            __display_name,
            __child_links,
            __short_representation,
            __metadata,
            __execution_stats,
            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 PlanNode")
                    }
                    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 {
                            "index" => Ok(__FieldTag::__index),
                            "kind" => Ok(__FieldTag::__kind),
                            "displayName" => Ok(__FieldTag::__display_name),
                            "display_name" => Ok(__FieldTag::__display_name),
                            "childLinks" => Ok(__FieldTag::__child_links),
                            "child_links" => Ok(__FieldTag::__child_links),
                            "shortRepresentation" => Ok(__FieldTag::__short_representation),
                            "short_representation" => Ok(__FieldTag::__short_representation),
                            "metadata" => Ok(__FieldTag::__metadata),
                            "executionStats" => Ok(__FieldTag::__execution_stats),
                            "execution_stats" => Ok(__FieldTag::__execution_stats),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::PlanNode;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct PlanNode")
            }
            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::__index => {
                            if !fields.insert(__FieldTag::__index) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for index",
                                ));
                            }
                            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.index = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__kind => {
                            if !fields.insert(__FieldTag::__kind) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for kind",
                                ));
                            }
                            result.kind = map
                                .next_value::<std::option::Option<crate::model::plan_node::Kind>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__display_name => {
                            if !fields.insert(__FieldTag::__display_name) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for display_name",
                                ));
                            }
                            result.display_name = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__child_links => {
                            if !fields.insert(__FieldTag::__child_links) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for child_links",
                                ));
                            }
                            result.child_links = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::model::plan_node::ChildLink>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__short_representation => {
                            if !fields.insert(__FieldTag::__short_representation) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for short_representation",
                                ));
                            }
                            result.short_representation =
                                map.next_value::<std::option::Option<
                                    crate::model::plan_node::ShortRepresentation,
                                >>()?;
                        }
                        __FieldTag::__metadata => {
                            if !fields.insert(__FieldTag::__metadata) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for metadata",
                                ));
                            }
                            result.metadata =
                                map.next_value::<std::option::Option<wkt::Struct>>()?;
                        }
                        __FieldTag::__execution_stats => {
                            if !fields.insert(__FieldTag::__execution_stats) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for execution_stats",
                                ));
                            }
                            result.execution_stats =
                                map.next_value::<std::option::Option<wkt::Struct>>()?;
                        }
                        __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::plan_node::ChildLink {
    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 {
            __child_index,
            __type,
            __variable,
            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 ChildLink")
                    }
                    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 {
                            "childIndex" => Ok(__FieldTag::__child_index),
                            "child_index" => Ok(__FieldTag::__child_index),
                            "type" => Ok(__FieldTag::__type),
                            "variable" => Ok(__FieldTag::__variable),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::plan_node::ChildLink;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ChildLink")
            }
            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::__child_index => {
                            if !fields.insert(__FieldTag::__child_index) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for child_index",
                                ));
                            }
                            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.child_index = map.next_value::<__With>()?.0.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<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__variable => {
                            if !fields.insert(__FieldTag::__variable) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for variable",
                                ));
                            }
                            result.variable = 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::plan_node::ShortRepresentation {
    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 {
            __description,
            __subqueries,
            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 ShortRepresentation")
                    }
                    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 {
                            "description" => Ok(__FieldTag::__description),
                            "subqueries" => Ok(__FieldTag::__subqueries),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::plan_node::ShortRepresentation;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ShortRepresentation")
            }
            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::__description => {
                            if !fields.insert(__FieldTag::__description) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for description",
                                ));
                            }
                            result.description = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__subqueries => {
                            if !fields.insert(__FieldTag::__subqueries) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for subqueries",
                                ));
                            }
                            struct __With(
                                std::option::Option<
                                    std::collections::HashMap<std::string::String, 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<
                                            std::collections::HashMap<
                                                serde_with::Same,
                                                wkt::internal::I32,
                                            >,
                                        >,
                                    >::deserialize(deserializer)
                                    .map(__With)
                                }
                            }
                            result.subqueries = 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::QueryAdvisorResult {
    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 {
            __index_advice,
            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 QueryAdvisorResult")
                    }
                    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 {
                            "indexAdvice" => Ok(__FieldTag::__index_advice),
                            "index_advice" => Ok(__FieldTag::__index_advice),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::QueryAdvisorResult;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct QueryAdvisorResult")
            }
            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::__index_advice => {
                            if !fields.insert(__FieldTag::__index_advice) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for index_advice",
                                ));
                            }
                            result.index_advice = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::model::query_advisor_result::IndexAdvice>,
                                >>()?
                                .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::query_advisor_result::IndexAdvice {
    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 {
            __ddl,
            __improvement_factor,
            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 IndexAdvice")
                    }
                    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 {
                            "ddl" => Ok(__FieldTag::__ddl),
                            "improvementFactor" => Ok(__FieldTag::__improvement_factor),
                            "improvement_factor" => Ok(__FieldTag::__improvement_factor),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::query_advisor_result::IndexAdvice;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct IndexAdvice")
            }
            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::__ddl => {
                            if !fields.insert(__FieldTag::__ddl) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for ddl",
                                ));
                            }
                            result.ddl = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__improvement_factor => {
                            if !fields.insert(__FieldTag::__improvement_factor) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for improvement_factor",
                                ));
                            }
                            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)
                                }
                            }
                            result.improvement_factor =
                                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::QueryPlan {
    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 {
            __plan_nodes,
            __query_advice,
            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 QueryPlan")
                    }
                    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 {
                            "planNodes" => Ok(__FieldTag::__plan_nodes),
                            "plan_nodes" => Ok(__FieldTag::__plan_nodes),
                            "queryAdvice" => Ok(__FieldTag::__query_advice),
                            "query_advice" => Ok(__FieldTag::__query_advice),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::QueryPlan;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct QueryPlan")
            }
            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::__plan_nodes => {
                            if !fields.insert(__FieldTag::__plan_nodes) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for plan_nodes",
                                ));
                            }
                            result.plan_nodes = map.next_value::<std::option::Option<std::vec::Vec<crate::model::PlanNode>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__query_advice => {
                            if !fields.insert(__FieldTag::__query_advice) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for query_advice",
                                ));
                            }
                            result.query_advice = map.next_value::<std::option::Option<crate::model::QueryAdvisorResult>>()?
                                ;
                        }
                        __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::ResultSet {
    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 {
            __metadata,
            __rows,
            __stats,
            __precommit_token,
            __cache_update,
            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 ResultSet")
                    }
                    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 {
                            "metadata" => Ok(__FieldTag::__metadata),
                            "rows" => Ok(__FieldTag::__rows),
                            "stats" => Ok(__FieldTag::__stats),
                            "precommitToken" => Ok(__FieldTag::__precommit_token),
                            "precommit_token" => Ok(__FieldTag::__precommit_token),
                            "cacheUpdate" => Ok(__FieldTag::__cache_update),
                            "cache_update" => Ok(__FieldTag::__cache_update),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::ResultSet;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ResultSet")
            }
            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::__metadata => {
                            if !fields.insert(__FieldTag::__metadata) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for metadata",
                                ));
                            }
                            result.metadata = map
                                .next_value::<std::option::Option<crate::model::ResultSetMetadata>>(
                                )?;
                        }
                        __FieldTag::__rows => {
                            if !fields.insert(__FieldTag::__rows) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for rows",
                                ));
                            }
                            result.rows = map
                                .next_value::<std::option::Option<std::vec::Vec<wkt::ListValue>>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__stats => {
                            if !fields.insert(__FieldTag::__stats) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for stats",
                                ));
                            }
                            result.stats = map
                                .next_value::<std::option::Option<crate::model::ResultSetStats>>(
                                )?;
                        }
                        __FieldTag::__precommit_token => {
                            if !fields.insert(__FieldTag::__precommit_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for precommit_token",
                                ));
                            }
                            result.precommit_token = map.next_value::<std::option::Option<
                                crate::model::MultiplexedSessionPrecommitToken,
                            >>()?;
                        }
                        __FieldTag::__cache_update => {
                            if !fields.insert(__FieldTag::__cache_update) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for cache_update",
                                ));
                            }
                            result.cache_update =
                                map.next_value::<std::option::Option<crate::model::CacheUpdate>>()?;
                        }
                        __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::PartialResultSet {
    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 {
            __metadata,
            __values,
            __chunked_value,
            __resume_token,
            __stats,
            __precommit_token,
            __last,
            __cache_update,
            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 PartialResultSet")
                    }
                    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 {
                            "metadata" => Ok(__FieldTag::__metadata),
                            "values" => Ok(__FieldTag::__values),
                            "chunkedValue" => Ok(__FieldTag::__chunked_value),
                            "chunked_value" => Ok(__FieldTag::__chunked_value),
                            "resumeToken" => Ok(__FieldTag::__resume_token),
                            "resume_token" => Ok(__FieldTag::__resume_token),
                            "stats" => Ok(__FieldTag::__stats),
                            "precommitToken" => Ok(__FieldTag::__precommit_token),
                            "precommit_token" => Ok(__FieldTag::__precommit_token),
                            "last" => Ok(__FieldTag::__last),
                            "cacheUpdate" => Ok(__FieldTag::__cache_update),
                            "cache_update" => Ok(__FieldTag::__cache_update),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::PartialResultSet;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct PartialResultSet")
            }
            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::__metadata => {
                            if !fields.insert(__FieldTag::__metadata) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for metadata",
                                ));
                            }
                            result.metadata = map
                                .next_value::<std::option::Option<crate::model::ResultSetMetadata>>(
                                )?;
                        }
                        __FieldTag::__values => {
                            if !fields.insert(__FieldTag::__values) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for values",
                                ));
                            }
                            result.values = map
                                .next_value::<std::option::Option<std::vec::Vec<wkt::Value>>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__chunked_value => {
                            if !fields.insert(__FieldTag::__chunked_value) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for chunked_value",
                                ));
                            }
                            result.chunked_value = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__resume_token => {
                            if !fields.insert(__FieldTag::__resume_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for resume_token",
                                ));
                            }
                            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.resume_token = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__stats => {
                            if !fields.insert(__FieldTag::__stats) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for stats",
                                ));
                            }
                            result.stats = map
                                .next_value::<std::option::Option<crate::model::ResultSetStats>>(
                                )?;
                        }
                        __FieldTag::__precommit_token => {
                            if !fields.insert(__FieldTag::__precommit_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for precommit_token",
                                ));
                            }
                            result.precommit_token = map.next_value::<std::option::Option<
                                crate::model::MultiplexedSessionPrecommitToken,
                            >>()?;
                        }
                        __FieldTag::__last => {
                            if !fields.insert(__FieldTag::__last) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for last",
                                ));
                            }
                            result.last = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__cache_update => {
                            if !fields.insert(__FieldTag::__cache_update) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for cache_update",
                                ));
                            }
                            result.cache_update =
                                map.next_value::<std::option::Option<crate::model::CacheUpdate>>()?;
                        }
                        __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::ResultSetMetadata {
    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 {
            __row_type,
            __transaction,
            __undeclared_parameters,
            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 ResultSetMetadata")
                    }
                    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 {
                            "rowType" => Ok(__FieldTag::__row_type),
                            "row_type" => Ok(__FieldTag::__row_type),
                            "transaction" => Ok(__FieldTag::__transaction),
                            "undeclaredParameters" => Ok(__FieldTag::__undeclared_parameters),
                            "undeclared_parameters" => Ok(__FieldTag::__undeclared_parameters),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::ResultSetMetadata;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ResultSetMetadata")
            }
            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::__row_type => {
                            if !fields.insert(__FieldTag::__row_type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for row_type",
                                ));
                            }
                            result.row_type =
                                map.next_value::<std::option::Option<crate::model::StructType>>()?;
                        }
                        __FieldTag::__transaction => {
                            if !fields.insert(__FieldTag::__transaction) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for transaction",
                                ));
                            }
                            result.transaction =
                                map.next_value::<std::option::Option<crate::model::Transaction>>()?;
                        }
                        __FieldTag::__undeclared_parameters => {
                            if !fields.insert(__FieldTag::__undeclared_parameters) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for undeclared_parameters",
                                ));
                            }
                            result.undeclared_parameters =
                                map.next_value::<std::option::Option<crate::model::StructType>>()?;
                        }
                        __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::ResultSetStats {
    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 {
            __query_plan,
            __query_stats,
            __row_count_exact,
            __row_count_lower_bound,
            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 ResultSetStats")
                    }
                    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 {
                            "queryPlan" => Ok(__FieldTag::__query_plan),
                            "query_plan" => Ok(__FieldTag::__query_plan),
                            "queryStats" => Ok(__FieldTag::__query_stats),
                            "query_stats" => Ok(__FieldTag::__query_stats),
                            "rowCountExact" => Ok(__FieldTag::__row_count_exact),
                            "row_count_exact" => Ok(__FieldTag::__row_count_exact),
                            "rowCountLowerBound" => Ok(__FieldTag::__row_count_lower_bound),
                            "row_count_lower_bound" => Ok(__FieldTag::__row_count_lower_bound),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::ResultSetStats;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ResultSetStats")
            }
            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::__query_plan => {
                            if !fields.insert(__FieldTag::__query_plan) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for query_plan",
                                ));
                            }
                            result.query_plan =
                                map.next_value::<std::option::Option<crate::model::QueryPlan>>()?;
                        }
                        __FieldTag::__query_stats => {
                            if !fields.insert(__FieldTag::__query_stats) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for query_stats",
                                ));
                            }
                            result.query_stats =
                                map.next_value::<std::option::Option<wkt::Struct>>()?;
                        }
                        __FieldTag::__row_count_exact => {
                            if !fields.insert(__FieldTag::__row_count_exact) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for row_count_exact",
                                ));
                            }
                            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)
                                }
                            }
                            if result.row_count.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `row_count`, a oneof with full ID .google.spanner.v1.ResultSetStats.row_count_exact, latest field was rowCountExact",
                                ));
                            }
                            result.row_count = std::option::Option::Some(
                                crate::model::result_set_stats::RowCount::RowCountExact(
                                    map.next_value::<__With>()?.0.unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__row_count_lower_bound => {
                            if !fields.insert(__FieldTag::__row_count_lower_bound) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for row_count_lower_bound",
                                ));
                            }
                            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)
                                }
                            }
                            if result.row_count.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `row_count`, a oneof with full ID .google.spanner.v1.ResultSetStats.row_count_lower_bound, latest field was rowCountLowerBound",
                                ));
                            }
                            result.row_count = std::option::Option::Some(
                                crate::model::result_set_stats::RowCount::RowCountLowerBound(
                                    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::CreateSessionRequest {
    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 {
            __database,
            __session,
            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 CreateSessionRequest")
                    }
                    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 {
                            "database" => Ok(__FieldTag::__database),
                            "session" => Ok(__FieldTag::__session),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::CreateSessionRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct CreateSessionRequest")
            }
            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::__database => {
                            if !fields.insert(__FieldTag::__database) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for database",
                                ));
                            }
                            result.database = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__session => {
                            if !fields.insert(__FieldTag::__session) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for session",
                                ));
                            }
                            result.session =
                                map.next_value::<std::option::Option<crate::model::Session>>()?;
                        }
                        __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::BatchCreateSessionsRequest {
    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 {
            __database,
            __session_template,
            __session_count,
            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 BatchCreateSessionsRequest")
                    }
                    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 {
                            "database" => Ok(__FieldTag::__database),
                            "sessionTemplate" => Ok(__FieldTag::__session_template),
                            "session_template" => Ok(__FieldTag::__session_template),
                            "sessionCount" => Ok(__FieldTag::__session_count),
                            "session_count" => Ok(__FieldTag::__session_count),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::BatchCreateSessionsRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct BatchCreateSessionsRequest")
            }
            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::__database => {
                            if !fields.insert(__FieldTag::__database) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for database",
                                ));
                            }
                            result.database = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__session_template => {
                            if !fields.insert(__FieldTag::__session_template) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for session_template",
                                ));
                            }
                            result.session_template =
                                map.next_value::<std::option::Option<crate::model::Session>>()?;
                        }
                        __FieldTag::__session_count => {
                            if !fields.insert(__FieldTag::__session_count) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for session_count",
                                ));
                            }
                            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.session_count =
                                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::BatchCreateSessionsResponse {
    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 {
            __session,
            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 BatchCreateSessionsResponse")
                    }
                    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 {
                            "session" => Ok(__FieldTag::__session),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::BatchCreateSessionsResponse;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct BatchCreateSessionsResponse")
            }
            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::__session => {
                            if !fields.insert(__FieldTag::__session) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for session",
                                ));
                            }
                            result.session = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Session>>>()?.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::Session {
    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,
            __labels,
            __create_time,
            __approximate_last_use_time,
            __creator_role,
            __multiplexed,
            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 Session")
                    }
                    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),
                            "labels" => Ok(__FieldTag::__labels),
                            "createTime" => Ok(__FieldTag::__create_time),
                            "create_time" => Ok(__FieldTag::__create_time),
                            "approximateLastUseTime" => Ok(__FieldTag::__approximate_last_use_time),
                            "approximate_last_use_time" => {
                                Ok(__FieldTag::__approximate_last_use_time)
                            }
                            "creatorRole" => Ok(__FieldTag::__creator_role),
                            "creator_role" => Ok(__FieldTag::__creator_role),
                            "multiplexed" => Ok(__FieldTag::__multiplexed),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::Session;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Session")
            }
            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::__labels => {
                            if !fields.insert(__FieldTag::__labels) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for labels",
                                ));
                            }
                            result.labels = map
                                .next_value::<std::option::Option<
                                    std::collections::HashMap<
                                        std::string::String,
                                        std::string::String,
                                    >,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__create_time => {
                            if !fields.insert(__FieldTag::__create_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for create_time",
                                ));
                            }
                            result.create_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__approximate_last_use_time => {
                            if !fields.insert(__FieldTag::__approximate_last_use_time) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for approximate_last_use_time",
                                ));
                            }
                            result.approximate_last_use_time =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__creator_role => {
                            if !fields.insert(__FieldTag::__creator_role) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for creator_role",
                                ));
                            }
                            result.creator_role = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__multiplexed => {
                            if !fields.insert(__FieldTag::__multiplexed) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for multiplexed",
                                ));
                            }
                            result.multiplexed = 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::GetSessionRequest {
    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,
            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 GetSessionRequest")
                    }
                    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),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::GetSessionRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct GetSessionRequest")
            }
            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::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::ListSessionsRequest {
    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 {
            __database,
            __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 ListSessionsRequest")
                    }
                    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 {
                            "database" => Ok(__FieldTag::__database),
                            "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::ListSessionsRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ListSessionsRequest")
            }
            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::__database => {
                            if !fields.insert(__FieldTag::__database) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for database",
                                ));
                            }
                            result.database = 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::ListSessionsResponse {
    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 {
            __sessions,
            __next_page_token,
            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 ListSessionsResponse")
                    }
                    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 {
                            "sessions" => Ok(__FieldTag::__sessions),
                            "nextPageToken" => Ok(__FieldTag::__next_page_token),
                            "next_page_token" => Ok(__FieldTag::__next_page_token),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::ListSessionsResponse;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ListSessionsResponse")
            }
            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::__sessions => {
                            if !fields.insert(__FieldTag::__sessions) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for sessions",
                                ));
                            }
                            result.sessions = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Session>>>()?.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::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::DeleteSessionRequest {
    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,
            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 DeleteSessionRequest")
                    }
                    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),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::DeleteSessionRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct DeleteSessionRequest")
            }
            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::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::RequestOptions {
    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 {
            __priority,
            __request_tag,
            __transaction_tag,
            __client_context,
            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 RequestOptions")
                    }
                    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 {
                            "priority" => Ok(__FieldTag::__priority),
                            "requestTag" => Ok(__FieldTag::__request_tag),
                            "request_tag" => Ok(__FieldTag::__request_tag),
                            "transactionTag" => Ok(__FieldTag::__transaction_tag),
                            "transaction_tag" => Ok(__FieldTag::__transaction_tag),
                            "clientContext" => Ok(__FieldTag::__client_context),
                            "client_context" => Ok(__FieldTag::__client_context),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::RequestOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct RequestOptions")
            }
            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::__priority => {
                            if !fields.insert(__FieldTag::__priority) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for priority",
                                ));
                            }
                            result.priority = map.next_value::<std::option::Option<crate::model::request_options::Priority>>()?.unwrap_or_default();
                        }
                        __FieldTag::__request_tag => {
                            if !fields.insert(__FieldTag::__request_tag) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for request_tag",
                                ));
                            }
                            result.request_tag = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__transaction_tag => {
                            if !fields.insert(__FieldTag::__transaction_tag) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for transaction_tag",
                                ));
                            }
                            result.transaction_tag = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__client_context => {
                            if !fields.insert(__FieldTag::__client_context) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for client_context",
                                ));
                            }
                            result.client_context =
                                map.next_value::<std::option::Option<
                                    crate::model::request_options::ClientContext,
                                >>()?;
                        }
                        __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::request_options::ClientContext {
    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 {
            __secure_context,
            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 ClientContext")
                    }
                    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 {
                            "secureContext" => Ok(__FieldTag::__secure_context),
                            "secure_context" => Ok(__FieldTag::__secure_context),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::request_options::ClientContext;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ClientContext")
            }
            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::__secure_context => {
                            if !fields.insert(__FieldTag::__secure_context) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for secure_context",
                                ));
                            }
                            result.secure_context = map
                                .next_value::<std::option::Option<
                                    std::collections::HashMap<std::string::String, wkt::Value>,
                                >>()?
                                .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::DirectedReadOptions {
    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 {
            __include_replicas,
            __exclude_replicas,
            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 DirectedReadOptions")
                    }
                    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 {
                            "includeReplicas" => Ok(__FieldTag::__include_replicas),
                            "include_replicas" => Ok(__FieldTag::__include_replicas),
                            "excludeReplicas" => Ok(__FieldTag::__exclude_replicas),
                            "exclude_replicas" => Ok(__FieldTag::__exclude_replicas),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::DirectedReadOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct DirectedReadOptions")
            }
            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::__include_replicas => {
                            if !fields.insert(__FieldTag::__include_replicas) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for include_replicas",
                                ));
                            }
                            if result.replicas.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `replicas`, a oneof with full ID .google.spanner.v1.DirectedReadOptions.include_replicas, latest field was includeReplicas",
                                ));
                            }
                            result.replicas = std::option::Option::Some(
                                crate::model::directed_read_options::Replicas::IncludeReplicas(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<
                                            crate::model::directed_read_options::IncludeReplicas,
                                        >,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__exclude_replicas => {
                            if !fields.insert(__FieldTag::__exclude_replicas) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for exclude_replicas",
                                ));
                            }
                            if result.replicas.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `replicas`, a oneof with full ID .google.spanner.v1.DirectedReadOptions.exclude_replicas, latest field was excludeReplicas",
                                ));
                            }
                            result.replicas = std::option::Option::Some(
                                crate::model::directed_read_options::Replicas::ExcludeReplicas(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<
                                            crate::model::directed_read_options::ExcludeReplicas,
                                        >,
                                    >>()?
                                    .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::directed_read_options::ReplicaSelection {
    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,
            __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 ReplicaSelection")
                    }
                    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),
                            "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::directed_read_options::ReplicaSelection;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ReplicaSelection")
            }
            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<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::directed_read_options::replica_selection::Type,
                                >>()?
                                .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::directed_read_options::IncludeReplicas {
    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 {
            __replica_selections,
            __auto_failover_disabled,
            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 IncludeReplicas")
                    }
                    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 {
                            "replicaSelections" => Ok(__FieldTag::__replica_selections),
                            "replica_selections" => Ok(__FieldTag::__replica_selections),
                            "autoFailoverDisabled" => Ok(__FieldTag::__auto_failover_disabled),
                            "auto_failover_disabled" => Ok(__FieldTag::__auto_failover_disabled),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::directed_read_options::IncludeReplicas;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct IncludeReplicas")
            }
            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::__replica_selections => {
                            if !fields.insert(__FieldTag::__replica_selections) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for replica_selections",
                                ));
                            }
                            result.replica_selections = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<
                                        crate::model::directed_read_options::ReplicaSelection,
                                    >,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__auto_failover_disabled => {
                            if !fields.insert(__FieldTag::__auto_failover_disabled) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for auto_failover_disabled",
                                ));
                            }
                            result.auto_failover_disabled = 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::directed_read_options::ExcludeReplicas {
    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 {
            __replica_selections,
            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 ExcludeReplicas")
                    }
                    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 {
                            "replicaSelections" => Ok(__FieldTag::__replica_selections),
                            "replica_selections" => Ok(__FieldTag::__replica_selections),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::directed_read_options::ExcludeReplicas;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ExcludeReplicas")
            }
            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::__replica_selections => {
                            if !fields.insert(__FieldTag::__replica_selections) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for replica_selections",
                                ));
                            }
                            result.replica_selections = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<
                                        crate::model::directed_read_options::ReplicaSelection,
                                    >,
                                >>()?
                                .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::ExecuteSqlRequest {
    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 {
            __session,
            __transaction,
            __sql,
            __params,
            __param_types,
            __resume_token,
            __query_mode,
            __partition_token,
            __seqno,
            __query_options,
            __request_options,
            __directed_read_options,
            __data_boost_enabled,
            __last_statement,
            __routing_hint,
            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 ExecuteSqlRequest")
                    }
                    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 {
                            "session" => Ok(__FieldTag::__session),
                            "transaction" => Ok(__FieldTag::__transaction),
                            "sql" => Ok(__FieldTag::__sql),
                            "params" => Ok(__FieldTag::__params),
                            "paramTypes" => Ok(__FieldTag::__param_types),
                            "param_types" => Ok(__FieldTag::__param_types),
                            "resumeToken" => Ok(__FieldTag::__resume_token),
                            "resume_token" => Ok(__FieldTag::__resume_token),
                            "queryMode" => Ok(__FieldTag::__query_mode),
                            "query_mode" => Ok(__FieldTag::__query_mode),
                            "partitionToken" => Ok(__FieldTag::__partition_token),
                            "partition_token" => Ok(__FieldTag::__partition_token),
                            "seqno" => Ok(__FieldTag::__seqno),
                            "queryOptions" => Ok(__FieldTag::__query_options),
                            "query_options" => Ok(__FieldTag::__query_options),
                            "requestOptions" => Ok(__FieldTag::__request_options),
                            "request_options" => Ok(__FieldTag::__request_options),
                            "directedReadOptions" => Ok(__FieldTag::__directed_read_options),
                            "directed_read_options" => Ok(__FieldTag::__directed_read_options),
                            "dataBoostEnabled" => Ok(__FieldTag::__data_boost_enabled),
                            "data_boost_enabled" => Ok(__FieldTag::__data_boost_enabled),
                            "lastStatement" => Ok(__FieldTag::__last_statement),
                            "last_statement" => Ok(__FieldTag::__last_statement),
                            "routingHint" => Ok(__FieldTag::__routing_hint),
                            "routing_hint" => Ok(__FieldTag::__routing_hint),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::ExecuteSqlRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ExecuteSqlRequest")
            }
            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::__session => {
                            if !fields.insert(__FieldTag::__session) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for session",
                                ));
                            }
                            result.session = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__transaction => {
                            if !fields.insert(__FieldTag::__transaction) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for transaction",
                                ));
                            }
                            result.transaction = map.next_value::<std::option::Option<crate::model::TransactionSelector>>()?
                                ;
                        }
                        __FieldTag::__sql => {
                            if !fields.insert(__FieldTag::__sql) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for sql",
                                ));
                            }
                            result.sql = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__params => {
                            if !fields.insert(__FieldTag::__params) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for params",
                                ));
                            }
                            result.params = map.next_value::<std::option::Option<wkt::Struct>>()?;
                        }
                        __FieldTag::__param_types => {
                            if !fields.insert(__FieldTag::__param_types) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for param_types",
                                ));
                            }
                            result.param_types = map
                                .next_value::<std::option::Option<
                                    std::collections::HashMap<
                                        std::string::String,
                                        crate::model::Type,
                                    >,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__resume_token => {
                            if !fields.insert(__FieldTag::__resume_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for resume_token",
                                ));
                            }
                            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.resume_token = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__query_mode => {
                            if !fields.insert(__FieldTag::__query_mode) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for query_mode",
                                ));
                            }
                            result.query_mode =
                                map.next_value::<std::option::Option<
                                    crate::model::execute_sql_request::QueryMode,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__partition_token => {
                            if !fields.insert(__FieldTag::__partition_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partition_token",
                                ));
                            }
                            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.partition_token =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__seqno => {
                            if !fields.insert(__FieldTag::__seqno) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for seqno",
                                ));
                            }
                            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.seqno = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__query_options => {
                            if !fields.insert(__FieldTag::__query_options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for query_options",
                                ));
                            }
                            result.query_options = map.next_value::<std::option::Option<
                                crate::model::execute_sql_request::QueryOptions,
                            >>()?;
                        }
                        __FieldTag::__request_options => {
                            if !fields.insert(__FieldTag::__request_options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for request_options",
                                ));
                            }
                            result.request_options = map
                                .next_value::<std::option::Option<crate::model::RequestOptions>>(
                                )?;
                        }
                        __FieldTag::__directed_read_options => {
                            if !fields.insert(__FieldTag::__directed_read_options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for directed_read_options",
                                ));
                            }
                            result.directed_read_options = map.next_value::<std::option::Option<crate::model::DirectedReadOptions>>()?
                                ;
                        }
                        __FieldTag::__data_boost_enabled => {
                            if !fields.insert(__FieldTag::__data_boost_enabled) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for data_boost_enabled",
                                ));
                            }
                            result.data_boost_enabled = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__last_statement => {
                            if !fields.insert(__FieldTag::__last_statement) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for last_statement",
                                ));
                            }
                            result.last_statement = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__routing_hint => {
                            if !fields.insert(__FieldTag::__routing_hint) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for routing_hint",
                                ));
                            }
                            result.routing_hint =
                                map.next_value::<std::option::Option<crate::model::RoutingHint>>()?;
                        }
                        __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::execute_sql_request::QueryOptions {
    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 {
            __optimizer_version,
            __optimizer_statistics_package,
            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 QueryOptions")
                    }
                    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 {
                            "optimizerVersion" => Ok(__FieldTag::__optimizer_version),
                            "optimizer_version" => Ok(__FieldTag::__optimizer_version),
                            "optimizerStatisticsPackage" => {
                                Ok(__FieldTag::__optimizer_statistics_package)
                            }
                            "optimizer_statistics_package" => {
                                Ok(__FieldTag::__optimizer_statistics_package)
                            }
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::execute_sql_request::QueryOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct QueryOptions")
            }
            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::__optimizer_version => {
                            if !fields.insert(__FieldTag::__optimizer_version) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for optimizer_version",
                                ));
                            }
                            result.optimizer_version = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__optimizer_statistics_package => {
                            if !fields.insert(__FieldTag::__optimizer_statistics_package) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for optimizer_statistics_package",
                                ));
                            }
                            result.optimizer_statistics_package = 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::ExecuteBatchDmlRequest {
    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 {
            __session,
            __transaction,
            __statements,
            __seqno,
            __request_options,
            __last_statements,
            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 ExecuteBatchDmlRequest")
                    }
                    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 {
                            "session" => Ok(__FieldTag::__session),
                            "transaction" => Ok(__FieldTag::__transaction),
                            "statements" => Ok(__FieldTag::__statements),
                            "seqno" => Ok(__FieldTag::__seqno),
                            "requestOptions" => Ok(__FieldTag::__request_options),
                            "request_options" => Ok(__FieldTag::__request_options),
                            "lastStatements" => Ok(__FieldTag::__last_statements),
                            "last_statements" => Ok(__FieldTag::__last_statements),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::ExecuteBatchDmlRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ExecuteBatchDmlRequest")
            }
            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::__session => {
                            if !fields.insert(__FieldTag::__session) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for session",
                                ));
                            }
                            result.session = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__transaction => {
                            if !fields.insert(__FieldTag::__transaction) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for transaction",
                                ));
                            }
                            result.transaction = map.next_value::<std::option::Option<crate::model::TransactionSelector>>()?
                                ;
                        }
                        __FieldTag::__statements => {
                            if !fields.insert(__FieldTag::__statements) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for statements",
                                ));
                            }
                            result.statements = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<
                                        crate::model::execute_batch_dml_request::Statement,
                                    >,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__seqno => {
                            if !fields.insert(__FieldTag::__seqno) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for seqno",
                                ));
                            }
                            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.seqno = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__request_options => {
                            if !fields.insert(__FieldTag::__request_options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for request_options",
                                ));
                            }
                            result.request_options = map
                                .next_value::<std::option::Option<crate::model::RequestOptions>>(
                                )?;
                        }
                        __FieldTag::__last_statements => {
                            if !fields.insert(__FieldTag::__last_statements) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for last_statements",
                                ));
                            }
                            result.last_statements = 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::execute_batch_dml_request::Statement {
    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 {
            __sql,
            __params,
            __param_types,
            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 Statement")
                    }
                    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 {
                            "sql" => Ok(__FieldTag::__sql),
                            "params" => Ok(__FieldTag::__params),
                            "paramTypes" => Ok(__FieldTag::__param_types),
                            "param_types" => Ok(__FieldTag::__param_types),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::execute_batch_dml_request::Statement;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Statement")
            }
            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::__sql => {
                            if !fields.insert(__FieldTag::__sql) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for sql",
                                ));
                            }
                            result.sql = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__params => {
                            if !fields.insert(__FieldTag::__params) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for params",
                                ));
                            }
                            result.params = map.next_value::<std::option::Option<wkt::Struct>>()?;
                        }
                        __FieldTag::__param_types => {
                            if !fields.insert(__FieldTag::__param_types) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for param_types",
                                ));
                            }
                            result.param_types = map
                                .next_value::<std::option::Option<
                                    std::collections::HashMap<
                                        std::string::String,
                                        crate::model::Type,
                                    >,
                                >>()?
                                .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::ExecuteBatchDmlResponse {
    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 {
            __result_sets,
            __status,
            __precommit_token,
            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 ExecuteBatchDmlResponse")
                    }
                    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 {
                            "resultSets" => Ok(__FieldTag::__result_sets),
                            "result_sets" => Ok(__FieldTag::__result_sets),
                            "status" => Ok(__FieldTag::__status),
                            "precommitToken" => Ok(__FieldTag::__precommit_token),
                            "precommit_token" => Ok(__FieldTag::__precommit_token),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::ExecuteBatchDmlResponse;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ExecuteBatchDmlResponse")
            }
            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::__result_sets => {
                            if !fields.insert(__FieldTag::__result_sets) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for result_sets",
                                ));
                            }
                            result.result_sets = map.next_value::<std::option::Option<std::vec::Vec<crate::model::ResultSet>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__status => {
                            if !fields.insert(__FieldTag::__status) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for status",
                                ));
                            }
                            result.status = map
                                .next_value::<std::option::Option<google_cloud_rpc::model::Status>>(
                                )?;
                        }
                        __FieldTag::__precommit_token => {
                            if !fields.insert(__FieldTag::__precommit_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for precommit_token",
                                ));
                            }
                            result.precommit_token = map.next_value::<std::option::Option<
                                crate::model::MultiplexedSessionPrecommitToken,
                            >>()?;
                        }
                        __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::PartitionOptions {
    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 {
            __partition_size_bytes,
            __max_partitions,
            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 PartitionOptions")
                    }
                    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 {
                            "partitionSizeBytes" => Ok(__FieldTag::__partition_size_bytes),
                            "partition_size_bytes" => Ok(__FieldTag::__partition_size_bytes),
                            "maxPartitions" => Ok(__FieldTag::__max_partitions),
                            "max_partitions" => Ok(__FieldTag::__max_partitions),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::PartitionOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct PartitionOptions")
            }
            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::__partition_size_bytes => {
                            if !fields.insert(__FieldTag::__partition_size_bytes) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partition_size_bytes",
                                ));
                            }
                            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.partition_size_bytes =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__max_partitions => {
                            if !fields.insert(__FieldTag::__max_partitions) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for max_partitions",
                                ));
                            }
                            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.max_partitions =
                                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::PartitionQueryRequest {
    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 {
            __session,
            __transaction,
            __sql,
            __params,
            __param_types,
            __partition_options,
            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 PartitionQueryRequest")
                    }
                    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 {
                            "session" => Ok(__FieldTag::__session),
                            "transaction" => Ok(__FieldTag::__transaction),
                            "sql" => Ok(__FieldTag::__sql),
                            "params" => Ok(__FieldTag::__params),
                            "paramTypes" => Ok(__FieldTag::__param_types),
                            "param_types" => Ok(__FieldTag::__param_types),
                            "partitionOptions" => Ok(__FieldTag::__partition_options),
                            "partition_options" => Ok(__FieldTag::__partition_options),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::PartitionQueryRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct PartitionQueryRequest")
            }
            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::__session => {
                            if !fields.insert(__FieldTag::__session) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for session",
                                ));
                            }
                            result.session = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__transaction => {
                            if !fields.insert(__FieldTag::__transaction) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for transaction",
                                ));
                            }
                            result.transaction = map.next_value::<std::option::Option<crate::model::TransactionSelector>>()?
                                ;
                        }
                        __FieldTag::__sql => {
                            if !fields.insert(__FieldTag::__sql) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for sql",
                                ));
                            }
                            result.sql = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__params => {
                            if !fields.insert(__FieldTag::__params) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for params",
                                ));
                            }
                            result.params = map.next_value::<std::option::Option<wkt::Struct>>()?;
                        }
                        __FieldTag::__param_types => {
                            if !fields.insert(__FieldTag::__param_types) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for param_types",
                                ));
                            }
                            result.param_types = map
                                .next_value::<std::option::Option<
                                    std::collections::HashMap<
                                        std::string::String,
                                        crate::model::Type,
                                    >,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__partition_options => {
                            if !fields.insert(__FieldTag::__partition_options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partition_options",
                                ));
                            }
                            result.partition_options = map
                                .next_value::<std::option::Option<crate::model::PartitionOptions>>(
                                )?;
                        }
                        __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::PartitionReadRequest {
    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 {
            __session,
            __transaction,
            __table,
            __index,
            __columns,
            __key_set,
            __partition_options,
            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 PartitionReadRequest")
                    }
                    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 {
                            "session" => Ok(__FieldTag::__session),
                            "transaction" => Ok(__FieldTag::__transaction),
                            "table" => Ok(__FieldTag::__table),
                            "index" => Ok(__FieldTag::__index),
                            "columns" => Ok(__FieldTag::__columns),
                            "keySet" => Ok(__FieldTag::__key_set),
                            "key_set" => Ok(__FieldTag::__key_set),
                            "partitionOptions" => Ok(__FieldTag::__partition_options),
                            "partition_options" => Ok(__FieldTag::__partition_options),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::PartitionReadRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct PartitionReadRequest")
            }
            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::__session => {
                            if !fields.insert(__FieldTag::__session) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for session",
                                ));
                            }
                            result.session = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__transaction => {
                            if !fields.insert(__FieldTag::__transaction) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for transaction",
                                ));
                            }
                            result.transaction = map.next_value::<std::option::Option<crate::model::TransactionSelector>>()?
                                ;
                        }
                        __FieldTag::__table => {
                            if !fields.insert(__FieldTag::__table) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for table",
                                ));
                            }
                            result.table = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__index => {
                            if !fields.insert(__FieldTag::__index) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for index",
                                ));
                            }
                            result.index = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__columns => {
                            if !fields.insert(__FieldTag::__columns) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for columns",
                                ));
                            }
                            result.columns = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__key_set => {
                            if !fields.insert(__FieldTag::__key_set) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for key_set",
                                ));
                            }
                            result.key_set =
                                map.next_value::<std::option::Option<crate::model::KeySet>>()?;
                        }
                        __FieldTag::__partition_options => {
                            if !fields.insert(__FieldTag::__partition_options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partition_options",
                                ));
                            }
                            result.partition_options = map
                                .next_value::<std::option::Option<crate::model::PartitionOptions>>(
                                )?;
                        }
                        __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::Partition {
    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 {
            __partition_token,
            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 Partition")
                    }
                    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 {
                            "partitionToken" => Ok(__FieldTag::__partition_token),
                            "partition_token" => Ok(__FieldTag::__partition_token),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::Partition;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Partition")
            }
            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::__partition_token => {
                            if !fields.insert(__FieldTag::__partition_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partition_token",
                                ));
                            }
                            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.partition_token =
                                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::PartitionResponse {
    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 {
            __partitions,
            __transaction,
            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 PartitionResponse")
                    }
                    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 {
                            "partitions" => Ok(__FieldTag::__partitions),
                            "transaction" => Ok(__FieldTag::__transaction),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::PartitionResponse;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct PartitionResponse")
            }
            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::__partitions => {
                            if !fields.insert(__FieldTag::__partitions) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partitions",
                                ));
                            }
                            result.partitions = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Partition>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__transaction => {
                            if !fields.insert(__FieldTag::__transaction) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for transaction",
                                ));
                            }
                            result.transaction =
                                map.next_value::<std::option::Option<crate::model::Transaction>>()?;
                        }
                        __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::ReadRequest {
    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 {
            __session,
            __transaction,
            __table,
            __index,
            __columns,
            __key_set,
            __limit,
            __resume_token,
            __partition_token,
            __request_options,
            __directed_read_options,
            __data_boost_enabled,
            __order_by,
            __lock_hint,
            __routing_hint,
            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 ReadRequest")
                    }
                    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 {
                            "session" => Ok(__FieldTag::__session),
                            "transaction" => Ok(__FieldTag::__transaction),
                            "table" => Ok(__FieldTag::__table),
                            "index" => Ok(__FieldTag::__index),
                            "columns" => Ok(__FieldTag::__columns),
                            "keySet" => Ok(__FieldTag::__key_set),
                            "key_set" => Ok(__FieldTag::__key_set),
                            "limit" => Ok(__FieldTag::__limit),
                            "resumeToken" => Ok(__FieldTag::__resume_token),
                            "resume_token" => Ok(__FieldTag::__resume_token),
                            "partitionToken" => Ok(__FieldTag::__partition_token),
                            "partition_token" => Ok(__FieldTag::__partition_token),
                            "requestOptions" => Ok(__FieldTag::__request_options),
                            "request_options" => Ok(__FieldTag::__request_options),
                            "directedReadOptions" => Ok(__FieldTag::__directed_read_options),
                            "directed_read_options" => Ok(__FieldTag::__directed_read_options),
                            "dataBoostEnabled" => Ok(__FieldTag::__data_boost_enabled),
                            "data_boost_enabled" => Ok(__FieldTag::__data_boost_enabled),
                            "orderBy" => Ok(__FieldTag::__order_by),
                            "order_by" => Ok(__FieldTag::__order_by),
                            "lockHint" => Ok(__FieldTag::__lock_hint),
                            "lock_hint" => Ok(__FieldTag::__lock_hint),
                            "routingHint" => Ok(__FieldTag::__routing_hint),
                            "routing_hint" => Ok(__FieldTag::__routing_hint),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::ReadRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ReadRequest")
            }
            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::__session => {
                            if !fields.insert(__FieldTag::__session) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for session",
                                ));
                            }
                            result.session = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__transaction => {
                            if !fields.insert(__FieldTag::__transaction) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for transaction",
                                ));
                            }
                            result.transaction = map.next_value::<std::option::Option<crate::model::TransactionSelector>>()?
                                ;
                        }
                        __FieldTag::__table => {
                            if !fields.insert(__FieldTag::__table) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for table",
                                ));
                            }
                            result.table = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__index => {
                            if !fields.insert(__FieldTag::__index) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for index",
                                ));
                            }
                            result.index = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__columns => {
                            if !fields.insert(__FieldTag::__columns) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for columns",
                                ));
                            }
                            result.columns = map.next_value::<std::option::Option<std::vec::Vec<std::string::String>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__key_set => {
                            if !fields.insert(__FieldTag::__key_set) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for key_set",
                                ));
                            }
                            result.key_set =
                                map.next_value::<std::option::Option<crate::model::KeySet>>()?;
                        }
                        __FieldTag::__limit => {
                            if !fields.insert(__FieldTag::__limit) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for limit",
                                ));
                            }
                            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.limit = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__resume_token => {
                            if !fields.insert(__FieldTag::__resume_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for resume_token",
                                ));
                            }
                            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.resume_token = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__partition_token => {
                            if !fields.insert(__FieldTag::__partition_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partition_token",
                                ));
                            }
                            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.partition_token =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__request_options => {
                            if !fields.insert(__FieldTag::__request_options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for request_options",
                                ));
                            }
                            result.request_options = map
                                .next_value::<std::option::Option<crate::model::RequestOptions>>(
                                )?;
                        }
                        __FieldTag::__directed_read_options => {
                            if !fields.insert(__FieldTag::__directed_read_options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for directed_read_options",
                                ));
                            }
                            result.directed_read_options = map.next_value::<std::option::Option<crate::model::DirectedReadOptions>>()?
                                ;
                        }
                        __FieldTag::__data_boost_enabled => {
                            if !fields.insert(__FieldTag::__data_boost_enabled) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for data_boost_enabled",
                                ));
                            }
                            result.data_boost_enabled = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__order_by => {
                            if !fields.insert(__FieldTag::__order_by) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for order_by",
                                ));
                            }
                            result.order_by = map.next_value::<std::option::Option<crate::model::read_request::OrderBy>>()?.unwrap_or_default();
                        }
                        __FieldTag::__lock_hint => {
                            if !fields.insert(__FieldTag::__lock_hint) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for lock_hint",
                                ));
                            }
                            result.lock_hint = map.next_value::<std::option::Option<crate::model::read_request::LockHint>>()?.unwrap_or_default();
                        }
                        __FieldTag::__routing_hint => {
                            if !fields.insert(__FieldTag::__routing_hint) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for routing_hint",
                                ));
                            }
                            result.routing_hint =
                                map.next_value::<std::option::Option<crate::model::RoutingHint>>()?;
                        }
                        __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::BeginTransactionRequest {
    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 {
            __session,
            __options,
            __request_options,
            __mutation_key,
            __routing_hint,
            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 BeginTransactionRequest")
                    }
                    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 {
                            "session" => Ok(__FieldTag::__session),
                            "options" => Ok(__FieldTag::__options),
                            "requestOptions" => Ok(__FieldTag::__request_options),
                            "request_options" => Ok(__FieldTag::__request_options),
                            "mutationKey" => Ok(__FieldTag::__mutation_key),
                            "mutation_key" => Ok(__FieldTag::__mutation_key),
                            "routingHint" => Ok(__FieldTag::__routing_hint),
                            "routing_hint" => Ok(__FieldTag::__routing_hint),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::BeginTransactionRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct BeginTransactionRequest")
            }
            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::__session => {
                            if !fields.insert(__FieldTag::__session) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for session",
                                ));
                            }
                            result.session = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__options => {
                            if !fields.insert(__FieldTag::__options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for options",
                                ));
                            }
                            result.options = map.next_value::<std::option::Option<crate::model::TransactionOptions>>()?
                                ;
                        }
                        __FieldTag::__request_options => {
                            if !fields.insert(__FieldTag::__request_options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for request_options",
                                ));
                            }
                            result.request_options = map
                                .next_value::<std::option::Option<crate::model::RequestOptions>>(
                                )?;
                        }
                        __FieldTag::__mutation_key => {
                            if !fields.insert(__FieldTag::__mutation_key) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for mutation_key",
                                ));
                            }
                            result.mutation_key =
                                map.next_value::<std::option::Option<crate::model::Mutation>>()?;
                        }
                        __FieldTag::__routing_hint => {
                            if !fields.insert(__FieldTag::__routing_hint) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for routing_hint",
                                ));
                            }
                            result.routing_hint =
                                map.next_value::<std::option::Option<crate::model::RoutingHint>>()?;
                        }
                        __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::CommitRequest {
    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 {
            __session,
            __transaction_id,
            __single_use_transaction,
            __mutations,
            __return_commit_stats,
            __max_commit_delay,
            __request_options,
            __precommit_token,
            __routing_hint,
            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 CommitRequest")
                    }
                    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 {
                            "session" => Ok(__FieldTag::__session),
                            "transactionId" => Ok(__FieldTag::__transaction_id),
                            "transaction_id" => Ok(__FieldTag::__transaction_id),
                            "singleUseTransaction" => Ok(__FieldTag::__single_use_transaction),
                            "single_use_transaction" => Ok(__FieldTag::__single_use_transaction),
                            "mutations" => Ok(__FieldTag::__mutations),
                            "returnCommitStats" => Ok(__FieldTag::__return_commit_stats),
                            "return_commit_stats" => Ok(__FieldTag::__return_commit_stats),
                            "maxCommitDelay" => Ok(__FieldTag::__max_commit_delay),
                            "max_commit_delay" => Ok(__FieldTag::__max_commit_delay),
                            "requestOptions" => Ok(__FieldTag::__request_options),
                            "request_options" => Ok(__FieldTag::__request_options),
                            "precommitToken" => Ok(__FieldTag::__precommit_token),
                            "precommit_token" => Ok(__FieldTag::__precommit_token),
                            "routingHint" => Ok(__FieldTag::__routing_hint),
                            "routing_hint" => Ok(__FieldTag::__routing_hint),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::CommitRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct CommitRequest")
            }
            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::__session => {
                            if !fields.insert(__FieldTag::__session) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for session",
                                ));
                            }
                            result.session = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__transaction_id => {
                            if !fields.insert(__FieldTag::__transaction_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for transaction_id",
                                ));
                            }
                            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)
                                }
                            }
                            if result.transaction.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `transaction`, a oneof with full ID .google.spanner.v1.CommitRequest.transaction_id, latest field was transactionId",
                                ));
                            }
                            result.transaction = std::option::Option::Some(
                                crate::model::commit_request::Transaction::TransactionId(
                                    map.next_value::<__With>()?.0.unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__single_use_transaction => {
                            if !fields.insert(__FieldTag::__single_use_transaction) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for single_use_transaction",
                                ));
                            }
                            if result.transaction.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `transaction`, a oneof with full ID .google.spanner.v1.CommitRequest.single_use_transaction, latest field was singleUseTransaction",
                                ));
                            }
                            result.transaction = std::option::Option::Some(
                                crate::model::commit_request::Transaction::SingleUseTransaction(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<crate::model::TransactionOptions>,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__mutations => {
                            if !fields.insert(__FieldTag::__mutations) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for mutations",
                                ));
                            }
                            result.mutations = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Mutation>>>()?.unwrap_or_default();
                        }
                        __FieldTag::__return_commit_stats => {
                            if !fields.insert(__FieldTag::__return_commit_stats) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for return_commit_stats",
                                ));
                            }
                            result.return_commit_stats = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__max_commit_delay => {
                            if !fields.insert(__FieldTag::__max_commit_delay) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for max_commit_delay",
                                ));
                            }
                            result.max_commit_delay =
                                map.next_value::<std::option::Option<wkt::Duration>>()?;
                        }
                        __FieldTag::__request_options => {
                            if !fields.insert(__FieldTag::__request_options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for request_options",
                                ));
                            }
                            result.request_options = map
                                .next_value::<std::option::Option<crate::model::RequestOptions>>(
                                )?;
                        }
                        __FieldTag::__precommit_token => {
                            if !fields.insert(__FieldTag::__precommit_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for precommit_token",
                                ));
                            }
                            result.precommit_token = map.next_value::<std::option::Option<
                                crate::model::MultiplexedSessionPrecommitToken,
                            >>()?;
                        }
                        __FieldTag::__routing_hint => {
                            if !fields.insert(__FieldTag::__routing_hint) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for routing_hint",
                                ));
                            }
                            result.routing_hint =
                                map.next_value::<std::option::Option<crate::model::RoutingHint>>()?;
                        }
                        __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::RollbackRequest {
    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 {
            __session,
            __transaction_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 RollbackRequest")
                    }
                    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 {
                            "session" => Ok(__FieldTag::__session),
                            "transactionId" => Ok(__FieldTag::__transaction_id),
                            "transaction_id" => Ok(__FieldTag::__transaction_id),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::RollbackRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct RollbackRequest")
            }
            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::__session => {
                            if !fields.insert(__FieldTag::__session) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for session",
                                ));
                            }
                            result.session = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__transaction_id => {
                            if !fields.insert(__FieldTag::__transaction_id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for transaction_id",
                                ));
                            }
                            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.transaction_id =
                                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::BatchWriteRequest {
    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 {
            __session,
            __request_options,
            __mutation_groups,
            __exclude_txn_from_change_streams,
            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 BatchWriteRequest")
                    }
                    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 {
                            "session" => Ok(__FieldTag::__session),
                            "requestOptions" => Ok(__FieldTag::__request_options),
                            "request_options" => Ok(__FieldTag::__request_options),
                            "mutationGroups" => Ok(__FieldTag::__mutation_groups),
                            "mutation_groups" => Ok(__FieldTag::__mutation_groups),
                            "excludeTxnFromChangeStreams" => {
                                Ok(__FieldTag::__exclude_txn_from_change_streams)
                            }
                            "exclude_txn_from_change_streams" => {
                                Ok(__FieldTag::__exclude_txn_from_change_streams)
                            }
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::BatchWriteRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct BatchWriteRequest")
            }
            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::__session => {
                            if !fields.insert(__FieldTag::__session) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for session",
                                ));
                            }
                            result.session = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__request_options => {
                            if !fields.insert(__FieldTag::__request_options) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for request_options",
                                ));
                            }
                            result.request_options = map
                                .next_value::<std::option::Option<crate::model::RequestOptions>>(
                                )?;
                        }
                        __FieldTag::__mutation_groups => {
                            if !fields.insert(__FieldTag::__mutation_groups) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for mutation_groups",
                                ));
                            }
                            result.mutation_groups = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::model::batch_write_request::MutationGroup>,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__exclude_txn_from_change_streams => {
                            if !fields.insert(__FieldTag::__exclude_txn_from_change_streams) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for exclude_txn_from_change_streams",
                                ));
                            }
                            result.exclude_txn_from_change_streams = 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::batch_write_request::MutationGroup {
    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 {
            __mutations,
            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 MutationGroup")
                    }
                    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 {
                            "mutations" => Ok(__FieldTag::__mutations),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::batch_write_request::MutationGroup;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct MutationGroup")
            }
            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::__mutations => {
                            if !fields.insert(__FieldTag::__mutations) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for mutations",
                                ));
                            }
                            result.mutations = map.next_value::<std::option::Option<std::vec::Vec<crate::model::Mutation>>>()?.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::BatchWriteResponse {
    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 {
            __indexes,
            __status,
            __commit_timestamp,
            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 BatchWriteResponse")
                    }
                    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 {
                            "indexes" => Ok(__FieldTag::__indexes),
                            "status" => Ok(__FieldTag::__status),
                            "commitTimestamp" => Ok(__FieldTag::__commit_timestamp),
                            "commit_timestamp" => Ok(__FieldTag::__commit_timestamp),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::BatchWriteResponse;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct BatchWriteResponse")
            }
            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::__indexes => {
                            if !fields.insert(__FieldTag::__indexes) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for indexes",
                                ));
                            }
                            struct __With(std::option::Option<std::vec::Vec<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<std::vec::Vec<wkt::internal::I32>>,
                                    >::deserialize(deserializer)
                                    .map(__With)
                                }
                            }
                            result.indexes = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__status => {
                            if !fields.insert(__FieldTag::__status) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for status",
                                ));
                            }
                            result.status = map
                                .next_value::<std::option::Option<google_cloud_rpc::model::Status>>(
                                )?;
                        }
                        __FieldTag::__commit_timestamp => {
                            if !fields.insert(__FieldTag::__commit_timestamp) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for commit_timestamp",
                                ));
                            }
                            result.commit_timestamp =
                                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::FetchCacheUpdateRequest {
    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 {
            __database,
            __max_recipe_count,
            __max_range_count,
            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 FetchCacheUpdateRequest")
                    }
                    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 {
                            "database" => Ok(__FieldTag::__database),
                            "maxRecipeCount" => Ok(__FieldTag::__max_recipe_count),
                            "max_recipe_count" => Ok(__FieldTag::__max_recipe_count),
                            "maxRangeCount" => Ok(__FieldTag::__max_range_count),
                            "max_range_count" => Ok(__FieldTag::__max_range_count),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::FetchCacheUpdateRequest;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct FetchCacheUpdateRequest")
            }
            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::__database => {
                            if !fields.insert(__FieldTag::__database) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for database",
                                ));
                            }
                            result.database = map
                                .next_value::<std::option::Option<std::string::String>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__max_recipe_count => {
                            if !fields.insert(__FieldTag::__max_recipe_count) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for max_recipe_count",
                                ));
                            }
                            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.max_recipe_count =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__max_range_count => {
                            if !fields.insert(__FieldTag::__max_range_count) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for max_range_count",
                                ));
                            }
                            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.max_range_count =
                                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::TransactionOptions {
    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 {
            __read_write,
            __partitioned_dml,
            __read_only,
            __exclude_txn_from_change_streams,
            __isolation_level,
            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 TransactionOptions")
                    }
                    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 {
                            "readWrite" => Ok(__FieldTag::__read_write),
                            "read_write" => Ok(__FieldTag::__read_write),
                            "partitionedDml" => Ok(__FieldTag::__partitioned_dml),
                            "partitioned_dml" => Ok(__FieldTag::__partitioned_dml),
                            "readOnly" => Ok(__FieldTag::__read_only),
                            "read_only" => Ok(__FieldTag::__read_only),
                            "excludeTxnFromChangeStreams" => {
                                Ok(__FieldTag::__exclude_txn_from_change_streams)
                            }
                            "exclude_txn_from_change_streams" => {
                                Ok(__FieldTag::__exclude_txn_from_change_streams)
                            }
                            "isolationLevel" => Ok(__FieldTag::__isolation_level),
                            "isolation_level" => Ok(__FieldTag::__isolation_level),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::TransactionOptions;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct TransactionOptions")
            }
            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::__read_write => {
                            if !fields.insert(__FieldTag::__read_write) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for read_write",
                                ));
                            }
                            if result.mode.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `mode`, a oneof with full ID .google.spanner.v1.TransactionOptions.read_write, latest field was readWrite",
                                ));
                            }
                            result.mode = std::option::Option::Some(
                                crate::model::transaction_options::Mode::ReadWrite(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<
                                            crate::model::transaction_options::ReadWrite,
                                        >,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__partitioned_dml => {
                            if !fields.insert(__FieldTag::__partitioned_dml) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for partitioned_dml",
                                ));
                            }
                            if result.mode.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `mode`, a oneof with full ID .google.spanner.v1.TransactionOptions.partitioned_dml, latest field was partitionedDml",
                                ));
                            }
                            result.mode = std::option::Option::Some(
                                crate::model::transaction_options::Mode::PartitionedDml(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<
                                            crate::model::transaction_options::PartitionedDml,
                                        >,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__read_only => {
                            if !fields.insert(__FieldTag::__read_only) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for read_only",
                                ));
                            }
                            if result.mode.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `mode`, a oneof with full ID .google.spanner.v1.TransactionOptions.read_only, latest field was readOnly",
                                ));
                            }
                            result.mode = std::option::Option::Some(
                                crate::model::transaction_options::Mode::ReadOnly(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<
                                            crate::model::transaction_options::ReadOnly,
                                        >,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__exclude_txn_from_change_streams => {
                            if !fields.insert(__FieldTag::__exclude_txn_from_change_streams) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for exclude_txn_from_change_streams",
                                ));
                            }
                            result.exclude_txn_from_change_streams = map
                                .next_value::<std::option::Option<bool>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__isolation_level => {
                            if !fields.insert(__FieldTag::__isolation_level) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for isolation_level",
                                ));
                            }
                            result.isolation_level = map
                                .next_value::<std::option::Option<
                                    crate::model::transaction_options::IsolationLevel,
                                >>()?
                                .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::transaction_options::ReadWrite {
    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 {
            __read_lock_mode,
            __multiplexed_session_previous_transaction_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 ReadWrite")
                    }
                    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 {
                            "readLockMode" => Ok(__FieldTag::__read_lock_mode),
                            "read_lock_mode" => Ok(__FieldTag::__read_lock_mode),
                            "multiplexedSessionPreviousTransactionId" => {
                                Ok(__FieldTag::__multiplexed_session_previous_transaction_id)
                            }
                            "multiplexed_session_previous_transaction_id" => {
                                Ok(__FieldTag::__multiplexed_session_previous_transaction_id)
                            }
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::transaction_options::ReadWrite;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ReadWrite")
            }
            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::__read_lock_mode => {
                            if !fields.insert(__FieldTag::__read_lock_mode) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for read_lock_mode",
                                ));
                            }
                            result.read_lock_mode = map
                                .next_value::<std::option::Option<
                                    crate::model::transaction_options::read_write::ReadLockMode,
                                >>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__multiplexed_session_previous_transaction_id => {
                            if !fields
                                .insert(__FieldTag::__multiplexed_session_previous_transaction_id)
                            {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for multiplexed_session_previous_transaction_id",
                                ));
                            }
                            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.multiplexed_session_previous_transaction_id =
                                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::transaction_options::PartitionedDml {
    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 {
            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 PartitionedDml")
                    }
                    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;
                        Ok(__FieldTag::Unknown(value.to_string()))
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::transaction_options::PartitionedDml;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct PartitionedDml")
            }
            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 result = Self::Value::new();
                while let Some(tag) = map.next_key::<__FieldTag>()? {
                    #[allow(clippy::match_single_binding)]
                    match tag {
                        __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::transaction_options::ReadOnly {
    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 {
            __strong,
            __min_read_timestamp,
            __max_staleness,
            __read_timestamp,
            __exact_staleness,
            __return_read_timestamp,
            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 ReadOnly")
                    }
                    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 {
                            "strong" => Ok(__FieldTag::__strong),
                            "minReadTimestamp" => Ok(__FieldTag::__min_read_timestamp),
                            "min_read_timestamp" => Ok(__FieldTag::__min_read_timestamp),
                            "maxStaleness" => Ok(__FieldTag::__max_staleness),
                            "max_staleness" => Ok(__FieldTag::__max_staleness),
                            "readTimestamp" => Ok(__FieldTag::__read_timestamp),
                            "read_timestamp" => Ok(__FieldTag::__read_timestamp),
                            "exactStaleness" => Ok(__FieldTag::__exact_staleness),
                            "exact_staleness" => Ok(__FieldTag::__exact_staleness),
                            "returnReadTimestamp" => Ok(__FieldTag::__return_read_timestamp),
                            "return_read_timestamp" => Ok(__FieldTag::__return_read_timestamp),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::transaction_options::ReadOnly;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct ReadOnly")
            }
            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::__strong => {
                            if !fields.insert(__FieldTag::__strong) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for strong",
                                ));
                            }
                            if result.timestamp_bound.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `timestamp_bound`, a oneof with full ID .google.spanner.v1.TransactionOptions.ReadOnly.strong, latest field was strong",
                                ));
                            }
                            result.timestamp_bound = std::option::Option::Some(
                                crate::model::transaction_options::read_only::TimestampBound::Strong(
                                    map.next_value::<std::option::Option<bool>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__min_read_timestamp => {
                            if !fields.insert(__FieldTag::__min_read_timestamp) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for min_read_timestamp",
                                ));
                            }
                            if result.timestamp_bound.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `timestamp_bound`, a oneof with full ID .google.spanner.v1.TransactionOptions.ReadOnly.min_read_timestamp, latest field was minReadTimestamp",
                                ));
                            }
                            result.timestamp_bound = std::option::Option::Some(
                                crate::model::transaction_options::read_only::TimestampBound::MinReadTimestamp(
                                    map.next_value::<std::option::Option<std::boxed::Box<wkt::Timestamp>>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__max_staleness => {
                            if !fields.insert(__FieldTag::__max_staleness) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for max_staleness",
                                ));
                            }
                            if result.timestamp_bound.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `timestamp_bound`, a oneof with full ID .google.spanner.v1.TransactionOptions.ReadOnly.max_staleness, latest field was maxStaleness",
                                ));
                            }
                            result.timestamp_bound = std::option::Option::Some(
                                crate::model::transaction_options::read_only::TimestampBound::MaxStaleness(
                                    map.next_value::<std::option::Option<std::boxed::Box<wkt::Duration>>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__read_timestamp => {
                            if !fields.insert(__FieldTag::__read_timestamp) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for read_timestamp",
                                ));
                            }
                            if result.timestamp_bound.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `timestamp_bound`, a oneof with full ID .google.spanner.v1.TransactionOptions.ReadOnly.read_timestamp, latest field was readTimestamp",
                                ));
                            }
                            result.timestamp_bound = std::option::Option::Some(
                                crate::model::transaction_options::read_only::TimestampBound::ReadTimestamp(
                                    map.next_value::<std::option::Option<std::boxed::Box<wkt::Timestamp>>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__exact_staleness => {
                            if !fields.insert(__FieldTag::__exact_staleness) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for exact_staleness",
                                ));
                            }
                            if result.timestamp_bound.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `timestamp_bound`, a oneof with full ID .google.spanner.v1.TransactionOptions.ReadOnly.exact_staleness, latest field was exactStaleness",
                                ));
                            }
                            result.timestamp_bound = std::option::Option::Some(
                                crate::model::transaction_options::read_only::TimestampBound::ExactStaleness(
                                    map.next_value::<std::option::Option<std::boxed::Box<wkt::Duration>>>()?.unwrap_or_default()
                                ),
                            );
                        }
                        __FieldTag::__return_read_timestamp => {
                            if !fields.insert(__FieldTag::__return_read_timestamp) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for return_read_timestamp",
                                ));
                            }
                            result.return_read_timestamp = 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::Transaction {
    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 {
            __id,
            __read_timestamp,
            __precommit_token,
            __cache_update,
            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 Transaction")
                    }
                    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 {
                            "id" => Ok(__FieldTag::__id),
                            "readTimestamp" => Ok(__FieldTag::__read_timestamp),
                            "read_timestamp" => Ok(__FieldTag::__read_timestamp),
                            "precommitToken" => Ok(__FieldTag::__precommit_token),
                            "precommit_token" => Ok(__FieldTag::__precommit_token),
                            "cacheUpdate" => Ok(__FieldTag::__cache_update),
                            "cache_update" => Ok(__FieldTag::__cache_update),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::Transaction;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Transaction")
            }
            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::__id => {
                            if !fields.insert(__FieldTag::__id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for id",
                                ));
                            }
                            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.id = map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__read_timestamp => {
                            if !fields.insert(__FieldTag::__read_timestamp) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for read_timestamp",
                                ));
                            }
                            result.read_timestamp =
                                map.next_value::<std::option::Option<wkt::Timestamp>>()?;
                        }
                        __FieldTag::__precommit_token => {
                            if !fields.insert(__FieldTag::__precommit_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for precommit_token",
                                ));
                            }
                            result.precommit_token = map.next_value::<std::option::Option<
                                crate::model::MultiplexedSessionPrecommitToken,
                            >>()?;
                        }
                        __FieldTag::__cache_update => {
                            if !fields.insert(__FieldTag::__cache_update) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for cache_update",
                                ));
                            }
                            result.cache_update =
                                map.next_value::<std::option::Option<crate::model::CacheUpdate>>()?;
                        }
                        __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::TransactionSelector {
    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 {
            __single_use,
            __id,
            __begin,
            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 TransactionSelector")
                    }
                    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 {
                            "singleUse" => Ok(__FieldTag::__single_use),
                            "single_use" => Ok(__FieldTag::__single_use),
                            "id" => Ok(__FieldTag::__id),
                            "begin" => Ok(__FieldTag::__begin),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::TransactionSelector;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct TransactionSelector")
            }
            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::__single_use => {
                            if !fields.insert(__FieldTag::__single_use) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for single_use",
                                ));
                            }
                            if result.selector.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `selector`, a oneof with full ID .google.spanner.v1.TransactionSelector.single_use, latest field was singleUse",
                                ));
                            }
                            result.selector = std::option::Option::Some(
                                crate::model::transaction_selector::Selector::SingleUse(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<crate::model::TransactionOptions>,
                                    >>()?
                                    .unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__id => {
                            if !fields.insert(__FieldTag::__id) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for id",
                                ));
                            }
                            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)
                                }
                            }
                            if result.selector.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `selector`, a oneof with full ID .google.spanner.v1.TransactionSelector.id, latest field was id",
                                ));
                            }
                            result.selector = std::option::Option::Some(
                                crate::model::transaction_selector::Selector::Id(
                                    map.next_value::<__With>()?.0.unwrap_or_default(),
                                ),
                            );
                        }
                        __FieldTag::__begin => {
                            if !fields.insert(__FieldTag::__begin) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for begin",
                                ));
                            }
                            if result.selector.is_some() {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for `selector`, a oneof with full ID .google.spanner.v1.TransactionSelector.begin, latest field was begin",
                                ));
                            }
                            result.selector = std::option::Option::Some(
                                crate::model::transaction_selector::Selector::Begin(
                                    map.next_value::<std::option::Option<
                                        std::boxed::Box<crate::model::TransactionOptions>,
                                    >>()?
                                    .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::MultiplexedSessionPrecommitToken {
    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 {
            __precommit_token,
            __seq_num,
            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 MultiplexedSessionPrecommitToken")
                    }
                    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 {
                            "precommitToken" => Ok(__FieldTag::__precommit_token),
                            "precommit_token" => Ok(__FieldTag::__precommit_token),
                            "seqNum" => Ok(__FieldTag::__seq_num),
                            "seq_num" => Ok(__FieldTag::__seq_num),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::MultiplexedSessionPrecommitToken;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct MultiplexedSessionPrecommitToken")
            }
            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::__precommit_token => {
                            if !fields.insert(__FieldTag::__precommit_token) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for precommit_token",
                                ));
                            }
                            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.precommit_token =
                                map.next_value::<__With>()?.0.unwrap_or_default();
                        }
                        __FieldTag::__seq_num => {
                            if !fields.insert(__FieldTag::__seq_num) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for seq_num",
                                ));
                            }
                            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.seq_num = 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::Type {
    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 {
            __code,
            __array_element_type,
            __struct_type,
            __type_annotation,
            __proto_type_fqn,
            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 Type")
                    }
                    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 {
                            "code" => Ok(__FieldTag::__code),
                            "arrayElementType" => Ok(__FieldTag::__array_element_type),
                            "array_element_type" => Ok(__FieldTag::__array_element_type),
                            "structType" => Ok(__FieldTag::__struct_type),
                            "struct_type" => Ok(__FieldTag::__struct_type),
                            "typeAnnotation" => Ok(__FieldTag::__type_annotation),
                            "type_annotation" => Ok(__FieldTag::__type_annotation),
                            "protoTypeFqn" => Ok(__FieldTag::__proto_type_fqn),
                            "proto_type_fqn" => Ok(__FieldTag::__proto_type_fqn),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::Type;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Type")
            }
            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::__code => {
                            if !fields.insert(__FieldTag::__code) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for code",
                                ));
                            }
                            result.code = map
                                .next_value::<std::option::Option<crate::model::TypeCode>>()?
                                .unwrap_or_default();
                        }
                        __FieldTag::__array_element_type => {
                            if !fields.insert(__FieldTag::__array_element_type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for array_element_type",
                                ));
                            }
                            result.array_element_type = map.next_value::<std::option::Option<std::boxed::Box<crate::model::Type>>>()?
                                ;
                        }
                        __FieldTag::__struct_type => {
                            if !fields.insert(__FieldTag::__struct_type) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for struct_type",
                                ));
                            }
                            result.struct_type = map.next_value::<std::option::Option<std::boxed::Box<crate::model::StructType>>>()?
                                ;
                        }
                        __FieldTag::__type_annotation => {
                            if !fields.insert(__FieldTag::__type_annotation) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for type_annotation",
                                ));
                            }
                            result.type_annotation = map.next_value::<std::option::Option<crate::model::TypeAnnotationCode>>()?.unwrap_or_default();
                        }
                        __FieldTag::__proto_type_fqn => {
                            if !fields.insert(__FieldTag::__proto_type_fqn) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for proto_type_fqn",
                                ));
                            }
                            result.proto_type_fqn = 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::StructType {
    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 {
            __fields,
            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 StructType")
                    }
                    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 {
                            "fields" => Ok(__FieldTag::__fields),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::StructType;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct StructType")
            }
            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::__fields => {
                            if !fields.insert(__FieldTag::__fields) {
                                return std::result::Result::Err(A::Error::duplicate_field(
                                    "multiple values for fields",
                                ));
                            }
                            result.fields = map
                                .next_value::<std::option::Option<
                                    std::vec::Vec<crate::model::struct_type::Field>,
                                >>()?
                                .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::struct_type::Field {
    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,
            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 Field")
                    }
                    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),
                            _ => Ok(__FieldTag::Unknown(value.to_string())),
                        }
                    }
                }
                deserializer.deserialize_identifier(Visitor)
            }
        }
        struct Visitor;
        impl<'de> serde::de::Visitor<'de> for Visitor {
            type Value = super::struct_type::Field;
            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("struct Field")
            }
            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<std::boxed::Box<crate::model::Type>>>()?
                                ;
                        }
                        __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)
    }
}