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.

impl gaxi::prost::ToProto<TypeCode> for crate::generated::gapic_dataplane::model::TypeCode {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::TypeCode"))
    }
}

impl gaxi::prost::ToProto<TypeAnnotationCode> for crate::generated::gapic_dataplane::model::TypeAnnotationCode {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::TypeAnnotationCode"))
    }
}

impl gaxi::prost::ToProto<change_stream_record::data_change_record::ColumnMetadata> for crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::ColumnMetadata {
    type Output = change_stream_record::data_change_record::ColumnMetadata;
    fn to_proto(self) -> std::result::Result<change_stream_record::data_change_record::ColumnMetadata, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            name: self.name.to_proto()?,
            r#type: self.r#type.map(|v| v.to_proto()).transpose()?,
            is_primary_key: self.is_primary_key.to_proto()?,
            ordinal_position: self.ordinal_position.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::ColumnMetadata> for change_stream_record::data_change_record::ColumnMetadata {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::ColumnMetadata, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::ColumnMetadata::new()
                .set_name(self.name)
                .set_or_clear_type(self.r#type.map(|v| v.cnv()).transpose()?)
                .set_is_primary_key(self.is_primary_key)
                .set_ordinal_position(self.ordinal_position)
        )
    }
}

impl gaxi::prost::ToProto<change_stream_record::data_change_record::ModValue> for crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::ModValue {
    type Output = change_stream_record::data_change_record::ModValue;
    fn to_proto(self) -> std::result::Result<change_stream_record::data_change_record::ModValue, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            column_metadata_index: self.column_metadata_index.to_proto()?,
            value: self.value.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::ModValue> for change_stream_record::data_change_record::ModValue {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::ModValue, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::ModValue::new()
                .set_column_metadata_index(self.column_metadata_index)
                .set_or_clear_value(self.value.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<change_stream_record::data_change_record::Mod> for crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::Mod {
    type Output = change_stream_record::data_change_record::Mod;
    fn to_proto(self) -> std::result::Result<change_stream_record::data_change_record::Mod, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            keys: self.keys
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            old_values: self.old_values
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            new_values: self.new_values
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::Mod> for change_stream_record::data_change_record::Mod {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::Mod, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::Mod::new()
                .set_keys(self.keys.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_old_values(self.old_values.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_new_values(self.new_values.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}

impl gaxi::prost::ToProto<change_stream_record::data_change_record::ModType> for crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::ModType {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::ModType"))
    }
}

impl gaxi::prost::ToProto<change_stream_record::data_change_record::ValueCaptureType> for crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::ValueCaptureType {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::change_stream_record::data_change_record::ValueCaptureType"))
    }
}

impl gaxi::prost::ToProto<change_stream_record::DataChangeRecord> for crate::generated::gapic_dataplane::model::change_stream_record::DataChangeRecord {
    type Output = change_stream_record::DataChangeRecord;
    fn to_proto(self) -> std::result::Result<change_stream_record::DataChangeRecord, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            commit_timestamp: self.commit_timestamp.map(|v| v.to_proto()).transpose()?,
            record_sequence: self.record_sequence.to_proto()?,
            server_transaction_id: self.server_transaction_id.to_proto()?,
            is_last_record_in_transaction_in_partition: self.is_last_record_in_transaction_in_partition.to_proto()?,
            table: self.table.to_proto()?,
            column_metadata: self.column_metadata
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            mods: self.mods
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            mod_type: self.mod_type.to_proto()?,
            value_capture_type: self.value_capture_type.to_proto()?,
            number_of_records_in_transaction: self.number_of_records_in_transaction.to_proto()?,
            number_of_partitions_in_transaction: self.number_of_partitions_in_transaction.to_proto()?,
            transaction_tag: self.transaction_tag.to_proto()?,
            is_system_transaction: self.is_system_transaction.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::change_stream_record::DataChangeRecord> for change_stream_record::DataChangeRecord {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::change_stream_record::DataChangeRecord, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::change_stream_record::DataChangeRecord::new()
                .set_or_clear_commit_timestamp(self.commit_timestamp.map(|v| v.cnv()).transpose()?)
                .set_record_sequence(self.record_sequence)
                .set_server_transaction_id(self.server_transaction_id)
                .set_is_last_record_in_transaction_in_partition(self.is_last_record_in_transaction_in_partition)
                .set_table(self.table)
                .set_column_metadata(self.column_metadata.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_mods(self.mods.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_mod_type(self.mod_type)
                .set_value_capture_type(self.value_capture_type)
                .set_number_of_records_in_transaction(self.number_of_records_in_transaction)
                .set_number_of_partitions_in_transaction(self.number_of_partitions_in_transaction)
                .set_transaction_tag(self.transaction_tag)
                .set_is_system_transaction(self.is_system_transaction)
        )
    }
}

impl gaxi::prost::ToProto<change_stream_record::HeartbeatRecord> for crate::generated::gapic_dataplane::model::change_stream_record::HeartbeatRecord {
    type Output = change_stream_record::HeartbeatRecord;
    fn to_proto(self) -> std::result::Result<change_stream_record::HeartbeatRecord, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            timestamp: self.timestamp.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::change_stream_record::HeartbeatRecord> for change_stream_record::HeartbeatRecord {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::change_stream_record::HeartbeatRecord, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::change_stream_record::HeartbeatRecord::new()
                .set_or_clear_timestamp(self.timestamp.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<change_stream_record::PartitionStartRecord> for crate::generated::gapic_dataplane::model::change_stream_record::PartitionStartRecord {
    type Output = change_stream_record::PartitionStartRecord;
    fn to_proto(self) -> std::result::Result<change_stream_record::PartitionStartRecord, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            start_timestamp: self.start_timestamp.map(|v| v.to_proto()).transpose()?,
            record_sequence: self.record_sequence.to_proto()?,
            partition_tokens: self.partition_tokens
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::change_stream_record::PartitionStartRecord> for change_stream_record::PartitionStartRecord {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::change_stream_record::PartitionStartRecord, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::change_stream_record::PartitionStartRecord::new()
                .set_or_clear_start_timestamp(self.start_timestamp.map(|v| v.cnv()).transpose()?)
                .set_record_sequence(self.record_sequence)
                .set_partition_tokens(self.partition_tokens.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}

impl gaxi::prost::ToProto<change_stream_record::PartitionEndRecord> for crate::generated::gapic_dataplane::model::change_stream_record::PartitionEndRecord {
    type Output = change_stream_record::PartitionEndRecord;
    fn to_proto(self) -> std::result::Result<change_stream_record::PartitionEndRecord, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            end_timestamp: self.end_timestamp.map(|v| v.to_proto()).transpose()?,
            record_sequence: self.record_sequence.to_proto()?,
            partition_token: self.partition_token.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::change_stream_record::PartitionEndRecord> for change_stream_record::PartitionEndRecord {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::change_stream_record::PartitionEndRecord, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::change_stream_record::PartitionEndRecord::new()
                .set_or_clear_end_timestamp(self.end_timestamp.map(|v| v.cnv()).transpose()?)
                .set_record_sequence(self.record_sequence)
                .set_partition_token(self.partition_token)
        )
    }
}

impl gaxi::prost::ToProto<change_stream_record::partition_event_record::MoveInEvent> for crate::generated::gapic_dataplane::model::change_stream_record::partition_event_record::MoveInEvent {
    type Output = change_stream_record::partition_event_record::MoveInEvent;
    fn to_proto(self) -> std::result::Result<change_stream_record::partition_event_record::MoveInEvent, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            source_partition_token: self.source_partition_token.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::change_stream_record::partition_event_record::MoveInEvent> for change_stream_record::partition_event_record::MoveInEvent {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::change_stream_record::partition_event_record::MoveInEvent, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::change_stream_record::partition_event_record::MoveInEvent::new()
                .set_source_partition_token(self.source_partition_token)
        )
    }
}

impl gaxi::prost::ToProto<change_stream_record::partition_event_record::MoveOutEvent> for crate::generated::gapic_dataplane::model::change_stream_record::partition_event_record::MoveOutEvent {
    type Output = change_stream_record::partition_event_record::MoveOutEvent;
    fn to_proto(self) -> std::result::Result<change_stream_record::partition_event_record::MoveOutEvent, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            destination_partition_token: self.destination_partition_token.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::change_stream_record::partition_event_record::MoveOutEvent> for change_stream_record::partition_event_record::MoveOutEvent {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::change_stream_record::partition_event_record::MoveOutEvent, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::change_stream_record::partition_event_record::MoveOutEvent::new()
                .set_destination_partition_token(self.destination_partition_token)
        )
    }
}

impl gaxi::prost::ToProto<change_stream_record::PartitionEventRecord> for crate::generated::gapic_dataplane::model::change_stream_record::PartitionEventRecord {
    type Output = change_stream_record::PartitionEventRecord;
    fn to_proto(self) -> std::result::Result<change_stream_record::PartitionEventRecord, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            commit_timestamp: self.commit_timestamp.map(|v| v.to_proto()).transpose()?,
            record_sequence: self.record_sequence.to_proto()?,
            partition_token: self.partition_token.to_proto()?,
            move_in_events: self.move_in_events
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            move_out_events: self.move_out_events
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::change_stream_record::PartitionEventRecord> for change_stream_record::PartitionEventRecord {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::change_stream_record::PartitionEventRecord, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::change_stream_record::PartitionEventRecord::new()
                .set_or_clear_commit_timestamp(self.commit_timestamp.map(|v| v.cnv()).transpose()?)
                .set_record_sequence(self.record_sequence)
                .set_partition_token(self.partition_token)
                .set_move_in_events(self.move_in_events.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_move_out_events(self.move_out_events.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}

impl gaxi::prost::ToProto<change_stream_record::Record> for crate::generated::gapic_dataplane::model::change_stream_record::Record {
    type Output = change_stream_record::Record;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::DataChangeRecord(v) => Ok(Self::Output::DataChangeRecord((*v).to_proto()?)),
            Self::HeartbeatRecord(v) => Ok(Self::Output::HeartbeatRecord((*v).to_proto()?)),
            Self::PartitionStartRecord(v) => Ok(Self::Output::PartitionStartRecord((*v).to_proto()?)),
            Self::PartitionEndRecord(v) => Ok(Self::Output::PartitionEndRecord((*v).to_proto()?)),
            Self::PartitionEventRecord(v) => Ok(Self::Output::PartitionEventRecord((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::change_stream_record::Record> for change_stream_record::Record {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::change_stream_record::Record, gaxi::prost::ConvertError> {
        use crate::generated::gapic_dataplane::model::change_stream_record::Record as T;
        match self {
            Self::DataChangeRecord(v) => Ok(T::from_data_change_record(v.cnv()?)),
            Self::HeartbeatRecord(v) => Ok(T::from_heartbeat_record(v.cnv()?)),
            Self::PartitionStartRecord(v) => Ok(T::from_partition_start_record(v.cnv()?)),
            Self::PartitionEndRecord(v) => Ok(T::from_partition_end_record(v.cnv()?)),
            Self::PartitionEventRecord(v) => Ok(T::from_partition_event_record(v.cnv()?)),
        }
    }
}

impl gaxi::prost::ToProto<ChangeStreamRecord> for crate::generated::gapic_dataplane::model::ChangeStreamRecord {
    type Output = ChangeStreamRecord;
    fn to_proto(self) -> std::result::Result<ChangeStreamRecord, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            record: self.record.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::ChangeStreamRecord> for ChangeStreamRecord {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::ChangeStreamRecord, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::ChangeStreamRecord::new()
                .set_record(self.record.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<commit_response::CommitStats> for crate::generated::gapic_dataplane::model::commit_response::CommitStats {
    type Output = commit_response::CommitStats;
    fn to_proto(self) -> std::result::Result<commit_response::CommitStats, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            mutation_count: self.mutation_count.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::commit_response::CommitStats> for commit_response::CommitStats {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::commit_response::CommitStats, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::commit_response::CommitStats::new()
                .set_mutation_count(self.mutation_count)
        )
    }
}

impl gaxi::prost::ToProto<commit_response::MultiplexedSessionRetry> for crate::generated::gapic_dataplane::model::commit_response::MultiplexedSessionRetry {
    type Output = commit_response::MultiplexedSessionRetry;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::PrecommitToken(v) => Ok(Self::Output::PrecommitToken((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::commit_response::MultiplexedSessionRetry> for commit_response::MultiplexedSessionRetry {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::commit_response::MultiplexedSessionRetry, gaxi::prost::ConvertError> {
        use crate::generated::gapic_dataplane::model::commit_response::MultiplexedSessionRetry as T;
        match self {
            Self::PrecommitToken(v) => Ok(T::from_precommit_token(v.cnv()?)),
        }
    }
}

impl gaxi::prost::ToProto<CommitResponse> for crate::generated::gapic_dataplane::model::CommitResponse {
    type Output = CommitResponse;
    fn to_proto(self) -> std::result::Result<CommitResponse, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            commit_timestamp: self.commit_timestamp.map(|v| v.to_proto()).transpose()?,
            commit_stats: self.commit_stats.map(|v| v.to_proto()).transpose()?,
            snapshot_timestamp: self.snapshot_timestamp.map(|v| v.to_proto()).transpose()?,
            cache_update: self.cache_update.map(|v| v.to_proto()).transpose()?,
            isolation_level: self.isolation_level.to_proto()?,
            read_lock_mode: self.read_lock_mode.to_proto()?,
            multiplexed_session_retry: self.multiplexed_session_retry.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::CommitResponse> for CommitResponse {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::CommitResponse, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::CommitResponse::new()
                .set_or_clear_commit_timestamp(self.commit_timestamp.map(|v| v.cnv()).transpose()?)
                .set_or_clear_commit_stats(self.commit_stats.map(|v| v.cnv()).transpose()?)
                .set_or_clear_snapshot_timestamp(self.snapshot_timestamp.map(|v| v.cnv()).transpose()?)
                .set_or_clear_cache_update(self.cache_update.map(|v| v.cnv()).transpose()?)
                .set_isolation_level(self.isolation_level)
                .set_read_lock_mode(self.read_lock_mode)
                .set_multiplexed_session_retry(self.multiplexed_session_retry.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<key_range::StartKeyType> for crate::generated::gapic_dataplane::model::key_range::StartKeyType {
    type Output = key_range::StartKeyType;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::StartClosed(v) => Ok(Self::Output::StartClosed((*v).to_proto()?)),
            Self::StartOpen(v) => Ok(Self::Output::StartOpen((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::key_range::StartKeyType> for key_range::StartKeyType {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::key_range::StartKeyType, gaxi::prost::ConvertError> {
        use crate::generated::gapic_dataplane::model::key_range::StartKeyType as T;
        match self {
            Self::StartClosed(v) => Ok(T::from_start_closed(v.cnv()?)),
            Self::StartOpen(v) => Ok(T::from_start_open(v.cnv()?)),
        }
    }
}

impl gaxi::prost::ToProto<key_range::EndKeyType> for crate::generated::gapic_dataplane::model::key_range::EndKeyType {
    type Output = key_range::EndKeyType;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::EndClosed(v) => Ok(Self::Output::EndClosed((*v).to_proto()?)),
            Self::EndOpen(v) => Ok(Self::Output::EndOpen((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::key_range::EndKeyType> for key_range::EndKeyType {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::key_range::EndKeyType, gaxi::prost::ConvertError> {
        use crate::generated::gapic_dataplane::model::key_range::EndKeyType as T;
        match self {
            Self::EndClosed(v) => Ok(T::from_end_closed(v.cnv()?)),
            Self::EndOpen(v) => Ok(T::from_end_open(v.cnv()?)),
        }
    }
}

impl gaxi::prost::ToProto<KeyRange> for crate::generated::gapic_dataplane::model::KeyRange {
    type Output = KeyRange;
    fn to_proto(self) -> std::result::Result<KeyRange, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            start_key_type: self.start_key_type.map(|v| v.to_proto()).transpose()?,
            end_key_type: self.end_key_type.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::KeyRange> for KeyRange {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::KeyRange, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::KeyRange::new()
                .set_start_key_type(self.start_key_type.map(|v| v.cnv()).transpose()?)
                .set_end_key_type(self.end_key_type.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<KeySet> for crate::generated::gapic_dataplane::model::KeySet {
    type Output = KeySet;
    fn to_proto(self) -> std::result::Result<KeySet, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            keys: self.keys
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ranges: self.ranges
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            all: self.all.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::KeySet> for KeySet {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::KeySet, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::KeySet::new()
                .set_keys(self.keys.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_ranges(self.ranges.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_all(self.all)
        )
    }
}

impl gaxi::prost::ToProto<Range> for crate::generated::gapic_dataplane::model::Range {
    type Output = Range;
    fn to_proto(self) -> std::result::Result<Range, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            start_key: self.start_key.to_proto()?,
            limit_key: self.limit_key.to_proto()?,
            group_uid: self.group_uid.to_proto()?,
            split_id: self.split_id.to_proto()?,
            generation: self.generation.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::Range> for Range {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::Range, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::Range::new()
                .set_start_key(self.start_key)
                .set_limit_key(self.limit_key)
                .set_group_uid(self.group_uid)
                .set_split_id(self.split_id)
                .set_generation(self.generation)
        )
    }
}

impl gaxi::prost::ToProto<tablet::Role> for crate::generated::gapic_dataplane::model::tablet::Role {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::tablet::Role"))
    }
}

impl gaxi::prost::ToProto<Tablet> for crate::generated::gapic_dataplane::model::Tablet {
    type Output = Tablet;
    fn to_proto(self) -> std::result::Result<Tablet, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            tablet_uid: self.tablet_uid.to_proto()?,
            server_address: self.server_address.to_proto()?,
            location: self.location.to_proto()?,
            role: self.role.to_proto()?,
            incarnation: self.incarnation.to_proto()?,
            distance: self.distance.to_proto()?,
            skip: self.skip.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::Tablet> for Tablet {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::Tablet, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::Tablet::new()
                .set_tablet_uid(self.tablet_uid)
                .set_server_address(self.server_address)
                .set_location(self.location)
                .set_role(self.role)
                .set_incarnation(self.incarnation)
                .set_distance(self.distance)
                .set_skip(self.skip)
        )
    }
}

impl gaxi::prost::ToProto<Group> for crate::generated::gapic_dataplane::model::Group {
    type Output = Group;
    fn to_proto(self) -> std::result::Result<Group, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            group_uid: self.group_uid.to_proto()?,
            tablets: self.tablets
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            leader_index: self.leader_index.to_proto()?,
            generation: self.generation.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::Group> for Group {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::Group, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::Group::new()
                .set_group_uid(self.group_uid)
                .set_tablets(self.tablets.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_leader_index(self.leader_index)
                .set_generation(self.generation)
        )
    }
}

impl gaxi::prost::ToProto<key_recipe::part::Order> for crate::generated::gapic_dataplane::model::key_recipe::part::Order {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::key_recipe::part::Order"))
    }
}

impl gaxi::prost::ToProto<key_recipe::part::NullOrder> for crate::generated::gapic_dataplane::model::key_recipe::part::NullOrder {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::key_recipe::part::NullOrder"))
    }
}

impl gaxi::prost::ToProto<key_recipe::part::ValueType> for crate::generated::gapic_dataplane::model::key_recipe::part::ValueType {
    type Output = key_recipe::part::ValueType;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::Identifier(v) => Ok(Self::Output::Identifier(v.to_proto()?)),
            Self::Value(v) => Ok(Self::Output::Value((*v).to_proto()?)),
            Self::Random(v) => Ok(Self::Output::Random(v.to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::key_recipe::part::ValueType> for key_recipe::part::ValueType {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::key_recipe::part::ValueType, gaxi::prost::ConvertError> {
        use crate::generated::gapic_dataplane::model::key_recipe::part::ValueType as T;
        match self {
            Self::Identifier(v) => Ok(T::from_identifier(v.cnv()?)),
            Self::Value(v) => Ok(T::from_value(v.cnv()?)),
            Self::Random(v) => Ok(T::from_random(v.cnv()?)),
        }
    }
}

impl gaxi::prost::ToProto<key_recipe::Part> for crate::generated::gapic_dataplane::model::key_recipe::Part {
    type Output = key_recipe::Part;
    fn to_proto(self) -> std::result::Result<key_recipe::Part, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            tag: self.tag.to_proto()?,
            order: self.order.to_proto()?,
            null_order: self.null_order.to_proto()?,
            r#type: self.r#type.map(|v| v.to_proto()).transpose()?,
            struct_identifiers: self.struct_identifiers
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            value_type: self.value_type.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::key_recipe::Part> for key_recipe::Part {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::key_recipe::Part, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::key_recipe::Part::new()
                .set_tag(self.tag)
                .set_order(self.order)
                .set_null_order(self.null_order)
                .set_or_clear_type(self.r#type.map(|v| v.cnv()).transpose()?)
                .set_struct_identifiers(self.struct_identifiers.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_value_type(self.value_type.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<key_recipe::Target> for crate::generated::gapic_dataplane::model::key_recipe::Target {
    type Output = key_recipe::Target;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::TableName(v) => Ok(Self::Output::TableName(v.to_proto()?)),
            Self::IndexName(v) => Ok(Self::Output::IndexName(v.to_proto()?)),
            Self::OperationUid(v) => Ok(Self::Output::OperationUid(v.to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::key_recipe::Target> for key_recipe::Target {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::key_recipe::Target, gaxi::prost::ConvertError> {
        use crate::generated::gapic_dataplane::model::key_recipe::Target as T;
        match self {
            Self::TableName(v) => Ok(T::from_table_name(v.cnv()?)),
            Self::IndexName(v) => Ok(T::from_index_name(v.cnv()?)),
            Self::OperationUid(v) => Ok(T::from_operation_uid(v.cnv()?)),
        }
    }
}

impl gaxi::prost::ToProto<KeyRecipe> for crate::generated::gapic_dataplane::model::KeyRecipe {
    type Output = KeyRecipe;
    fn to_proto(self) -> std::result::Result<KeyRecipe, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            part: self.part
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            target: self.target.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::KeyRecipe> for KeyRecipe {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::KeyRecipe, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::KeyRecipe::new()
                .set_part(self.part.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_target(self.target.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<RecipeList> for crate::generated::gapic_dataplane::model::RecipeList {
    type Output = RecipeList;
    fn to_proto(self) -> std::result::Result<RecipeList, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            schema_generation: self.schema_generation.to_proto()?,
            recipe: self.recipe
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::RecipeList> for RecipeList {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::RecipeList, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::RecipeList::new()
                .set_schema_generation(self.schema_generation)
                .set_recipe(self.recipe.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}

impl gaxi::prost::ToProto<CacheUpdate> for crate::generated::gapic_dataplane::model::CacheUpdate {
    type Output = CacheUpdate;
    fn to_proto(self) -> std::result::Result<CacheUpdate, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            database_id: self.database_id.to_proto()?,
            range: self.range
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            group: self.group
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            key_recipes: self.key_recipes.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::CacheUpdate> for CacheUpdate {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::CacheUpdate, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::CacheUpdate::new()
                .set_database_id(self.database_id)
                .set_range(self.range.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_group(self.group.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_or_clear_key_recipes(self.key_recipes.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<routing_hint::SkippedTablet> for crate::generated::gapic_dataplane::model::routing_hint::SkippedTablet {
    type Output = routing_hint::SkippedTablet;
    fn to_proto(self) -> std::result::Result<routing_hint::SkippedTablet, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            tablet_uid: self.tablet_uid.to_proto()?,
            incarnation: self.incarnation.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::routing_hint::SkippedTablet> for routing_hint::SkippedTablet {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::routing_hint::SkippedTablet, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::routing_hint::SkippedTablet::new()
                .set_tablet_uid(self.tablet_uid)
                .set_incarnation(self.incarnation)
        )
    }
}

impl gaxi::prost::ToProto<RoutingHint> for crate::generated::gapic_dataplane::model::RoutingHint {
    type Output = RoutingHint;
    fn to_proto(self) -> std::result::Result<RoutingHint, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            operation_uid: self.operation_uid.to_proto()?,
            database_id: self.database_id.to_proto()?,
            schema_generation: self.schema_generation.to_proto()?,
            key: self.key.to_proto()?,
            limit_key: self.limit_key.to_proto()?,
            group_uid: self.group_uid.to_proto()?,
            split_id: self.split_id.to_proto()?,
            tablet_uid: self.tablet_uid.to_proto()?,
            skipped_tablet_uid: self.skipped_tablet_uid
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            client_location: self.client_location.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::RoutingHint> for RoutingHint {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::RoutingHint, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::RoutingHint::new()
                .set_operation_uid(self.operation_uid)
                .set_database_id(self.database_id)
                .set_schema_generation(self.schema_generation)
                .set_key(self.key)
                .set_limit_key(self.limit_key)
                .set_group_uid(self.group_uid)
                .set_split_id(self.split_id)
                .set_tablet_uid(self.tablet_uid)
                .set_skipped_tablet_uid(self.skipped_tablet_uid.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_client_location(self.client_location)
        )
    }
}

impl gaxi::prost::ToProto<mutation::Write> for crate::generated::gapic_dataplane::model::mutation::Write {
    type Output = mutation::Write;
    fn to_proto(self) -> std::result::Result<mutation::Write, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            table: self.table.to_proto()?,
            columns: self.columns
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            values: self.values
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::mutation::Write> for mutation::Write {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::mutation::Write, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::mutation::Write::new()
                .set_table(self.table)
                .set_columns(self.columns.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_values(self.values.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}

impl gaxi::prost::ToProto<mutation::Delete> for crate::generated::gapic_dataplane::model::mutation::Delete {
    type Output = mutation::Delete;
    fn to_proto(self) -> std::result::Result<mutation::Delete, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            table: self.table.to_proto()?,
            key_set: self.key_set.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::mutation::Delete> for mutation::Delete {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::mutation::Delete, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::mutation::Delete::new()
                .set_table(self.table)
                .set_or_clear_key_set(self.key_set.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<mutation::Send> for crate::generated::gapic_dataplane::model::mutation::Send {
    type Output = mutation::Send;
    fn to_proto(self) -> std::result::Result<mutation::Send, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            queue: self.queue.to_proto()?,
            key: self.key.map(|v| v.to_proto()).transpose()?,
            deliver_time: self.deliver_time.map(|v| v.to_proto()).transpose()?,
            payload: self.payload.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::mutation::Send> for mutation::Send {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::mutation::Send, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::mutation::Send::new()
                .set_queue(self.queue)
                .set_or_clear_key(self.key.map(|v| v.cnv()).transpose()?)
                .set_or_clear_deliver_time(self.deliver_time.map(|v| v.cnv()).transpose()?)
                .set_or_clear_payload(self.payload.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<mutation::Ack> for crate::generated::gapic_dataplane::model::mutation::Ack {
    type Output = mutation::Ack;
    fn to_proto(self) -> std::result::Result<mutation::Ack, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            queue: self.queue.to_proto()?,
            key: self.key.map(|v| v.to_proto()).transpose()?,
            ignore_not_found: self.ignore_not_found.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::mutation::Ack> for mutation::Ack {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::mutation::Ack, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::mutation::Ack::new()
                .set_queue(self.queue)
                .set_or_clear_key(self.key.map(|v| v.cnv()).transpose()?)
                .set_ignore_not_found(self.ignore_not_found)
        )
    }
}

impl gaxi::prost::ToProto<mutation::Operation> for crate::generated::gapic_dataplane::model::mutation::Operation {
    type Output = mutation::Operation;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::Insert(v) => Ok(Self::Output::Insert((*v).to_proto()?)),
            Self::Update(v) => Ok(Self::Output::Update((*v).to_proto()?)),
            Self::InsertOrUpdate(v) => Ok(Self::Output::InsertOrUpdate((*v).to_proto()?)),
            Self::Replace(v) => Ok(Self::Output::Replace((*v).to_proto()?)),
            Self::Delete(v) => Ok(Self::Output::Delete((*v).to_proto()?)),
            Self::Send(v) => Ok(Self::Output::Send((*v).to_proto()?)),
            Self::Ack(v) => Ok(Self::Output::Ack((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::mutation::Operation> for mutation::Operation {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::mutation::Operation, gaxi::prost::ConvertError> {
        use crate::generated::gapic_dataplane::model::mutation::Operation as T;
        match self {
            Self::Insert(v) => Ok(T::from_insert(v.cnv()?)),
            Self::Update(v) => Ok(T::from_update(v.cnv()?)),
            Self::InsertOrUpdate(v) => Ok(T::from_insert_or_update(v.cnv()?)),
            Self::Replace(v) => Ok(T::from_replace(v.cnv()?)),
            Self::Delete(v) => Ok(T::from_delete(v.cnv()?)),
            Self::Send(v) => Ok(T::from_send(v.cnv()?)),
            Self::Ack(v) => Ok(T::from_ack(v.cnv()?)),
        }
    }
}

impl gaxi::prost::ToProto<Mutation> for crate::generated::gapic_dataplane::model::Mutation {
    type Output = Mutation;
    fn to_proto(self) -> std::result::Result<Mutation, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            operation: self.operation.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::Mutation> for Mutation {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::Mutation, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::Mutation::new()
                .set_operation(self.operation.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<plan_node::ChildLink> for crate::generated::gapic_dataplane::model::plan_node::ChildLink {
    type Output = plan_node::ChildLink;
    fn to_proto(self) -> std::result::Result<plan_node::ChildLink, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            child_index: self.child_index.to_proto()?,
            r#type: self.r#type.to_proto()?,
            variable: self.variable.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::plan_node::ChildLink> for plan_node::ChildLink {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::plan_node::ChildLink, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::plan_node::ChildLink::new()
                .set_child_index(self.child_index)
                .set_type(self.r#type)
                .set_variable(self.variable)
        )
    }
}

impl gaxi::prost::ToProto<plan_node::ShortRepresentation> for crate::generated::gapic_dataplane::model::plan_node::ShortRepresentation {
    type Output = plan_node::ShortRepresentation;
    fn to_proto(self) -> std::result::Result<plan_node::ShortRepresentation, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            description: self.description.to_proto()?,
            subqueries: self.subqueries
                .into_iter()
                .map(|(k, v)| {
                    gaxi::prost::pair_transpose(k.to_proto(), v.to_proto())
                }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::plan_node::ShortRepresentation> for plan_node::ShortRepresentation {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::plan_node::ShortRepresentation, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::plan_node::ShortRepresentation::new()
                .set_description(self.description)
                .set_subqueries(self.subqueries.into_iter()
                    .map(|(k, v)| {
                        gaxi::prost::pair_transpose(k.cnv(), v.cnv())
                    }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?)
        )
    }
}

impl gaxi::prost::ToProto<plan_node::Kind> for crate::generated::gapic_dataplane::model::plan_node::Kind {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::plan_node::Kind"))
    }
}

impl gaxi::prost::ToProto<PlanNode> for crate::generated::gapic_dataplane::model::PlanNode {
    type Output = PlanNode;
    fn to_proto(self) -> std::result::Result<PlanNode, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            index: self.index.to_proto()?,
            kind: self.kind.to_proto()?,
            display_name: self.display_name.to_proto()?,
            child_links: self.child_links
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            short_representation: self.short_representation.map(|v| v.to_proto()).transpose()?,
            metadata: self.metadata.map(|v| v.to_proto()).transpose()?,
            execution_stats: self.execution_stats.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::PlanNode> for PlanNode {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::PlanNode, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::PlanNode::new()
                .set_index(self.index)
                .set_kind(self.kind)
                .set_display_name(self.display_name)
                .set_child_links(self.child_links.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_or_clear_short_representation(self.short_representation.map(|v| v.cnv()).transpose()?)
                .set_or_clear_metadata(self.metadata.map(|v| v.cnv()).transpose()?)
                .set_or_clear_execution_stats(self.execution_stats.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<query_advisor_result::IndexAdvice> for crate::generated::gapic_dataplane::model::query_advisor_result::IndexAdvice {
    type Output = query_advisor_result::IndexAdvice;
    fn to_proto(self) -> std::result::Result<query_advisor_result::IndexAdvice, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            ddl: self.ddl
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            improvement_factor: self.improvement_factor.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::query_advisor_result::IndexAdvice> for query_advisor_result::IndexAdvice {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::query_advisor_result::IndexAdvice, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::query_advisor_result::IndexAdvice::new()
                .set_ddl(self.ddl.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_improvement_factor(self.improvement_factor)
        )
    }
}

impl gaxi::prost::ToProto<QueryAdvisorResult> for crate::generated::gapic_dataplane::model::QueryAdvisorResult {
    type Output = QueryAdvisorResult;
    fn to_proto(self) -> std::result::Result<QueryAdvisorResult, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            index_advice: self.index_advice
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::QueryAdvisorResult> for QueryAdvisorResult {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::QueryAdvisorResult, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::QueryAdvisorResult::new()
                .set_index_advice(self.index_advice.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}

impl gaxi::prost::ToProto<QueryPlan> for crate::generated::gapic_dataplane::model::QueryPlan {
    type Output = QueryPlan;
    fn to_proto(self) -> std::result::Result<QueryPlan, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            plan_nodes: self.plan_nodes
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            query_advice: self.query_advice.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::QueryPlan> for QueryPlan {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::QueryPlan, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::QueryPlan::new()
                .set_plan_nodes(self.plan_nodes.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_or_clear_query_advice(self.query_advice.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<ResultSet> for crate::generated::gapic_dataplane::model::ResultSet {
    type Output = ResultSet;
    fn to_proto(self) -> std::result::Result<ResultSet, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            metadata: self.metadata.map(|v| v.to_proto()).transpose()?,
            rows: self.rows
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            stats: self.stats.map(|v| v.to_proto()).transpose()?,
            precommit_token: self.precommit_token.map(|v| v.to_proto()).transpose()?,
            cache_update: self.cache_update.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::ResultSet> for ResultSet {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::ResultSet, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::ResultSet::new()
                .set_or_clear_metadata(self.metadata.map(|v| v.cnv()).transpose()?)
                .set_rows(self.rows.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_or_clear_stats(self.stats.map(|v| v.cnv()).transpose()?)
                .set_or_clear_precommit_token(self.precommit_token.map(|v| v.cnv()).transpose()?)
                .set_or_clear_cache_update(self.cache_update.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<PartialResultSet> for crate::generated::gapic_dataplane::model::PartialResultSet {
    type Output = PartialResultSet;
    fn to_proto(self) -> std::result::Result<PartialResultSet, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            metadata: self.metadata.map(|v| v.to_proto()).transpose()?,
            values: self.values
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            chunked_value: self.chunked_value.to_proto()?,
            resume_token: self.resume_token.to_proto()?,
            stats: self.stats.map(|v| v.to_proto()).transpose()?,
            precommit_token: self.precommit_token.map(|v| v.to_proto()).transpose()?,
            last: self.last.to_proto()?,
            cache_update: self.cache_update.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::PartialResultSet> for PartialResultSet {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::PartialResultSet, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::PartialResultSet::new()
                .set_or_clear_metadata(self.metadata.map(|v| v.cnv()).transpose()?)
                .set_values(self.values.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_chunked_value(self.chunked_value)
                .set_resume_token(self.resume_token)
                .set_or_clear_stats(self.stats.map(|v| v.cnv()).transpose()?)
                .set_or_clear_precommit_token(self.precommit_token.map(|v| v.cnv()).transpose()?)
                .set_last(self.last)
                .set_or_clear_cache_update(self.cache_update.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<ResultSetMetadata> for crate::generated::gapic_dataplane::model::ResultSetMetadata {
    type Output = ResultSetMetadata;
    fn to_proto(self) -> std::result::Result<ResultSetMetadata, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            row_type: self.row_type.map(|v| v.to_proto()).transpose()?,
            transaction: self.transaction.map(|v| v.to_proto()).transpose()?,
            undeclared_parameters: self.undeclared_parameters.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::ResultSetMetadata> for ResultSetMetadata {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::ResultSetMetadata, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::ResultSetMetadata::new()
                .set_or_clear_row_type(self.row_type.map(|v| v.cnv()).transpose()?)
                .set_or_clear_transaction(self.transaction.map(|v| v.cnv()).transpose()?)
                .set_or_clear_undeclared_parameters(self.undeclared_parameters.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<result_set_stats::RowCount> for crate::generated::gapic_dataplane::model::result_set_stats::RowCount {
    type Output = result_set_stats::RowCount;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::RowCountExact(v) => Ok(Self::Output::RowCountExact(v.to_proto()?)),
            Self::RowCountLowerBound(v) => Ok(Self::Output::RowCountLowerBound(v.to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::result_set_stats::RowCount> for result_set_stats::RowCount {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::result_set_stats::RowCount, gaxi::prost::ConvertError> {
        use crate::generated::gapic_dataplane::model::result_set_stats::RowCount as T;
        match self {
            Self::RowCountExact(v) => Ok(T::from_row_count_exact(v.cnv()?)),
            Self::RowCountLowerBound(v) => Ok(T::from_row_count_lower_bound(v.cnv()?)),
        }
    }
}

impl gaxi::prost::ToProto<ResultSetStats> for crate::generated::gapic_dataplane::model::ResultSetStats {
    type Output = ResultSetStats;
    fn to_proto(self) -> std::result::Result<ResultSetStats, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            query_plan: self.query_plan.map(|v| v.to_proto()).transpose()?,
            query_stats: self.query_stats.map(|v| v.to_proto()).transpose()?,
            row_count: self.row_count.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::ResultSetStats> for ResultSetStats {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::ResultSetStats, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::ResultSetStats::new()
                .set_or_clear_query_plan(self.query_plan.map(|v| v.cnv()).transpose()?)
                .set_or_clear_query_stats(self.query_stats.map(|v| v.cnv()).transpose()?)
                .set_row_count(self.row_count.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<CreateSessionRequest> for crate::generated::gapic_dataplane::model::CreateSessionRequest {
    type Output = CreateSessionRequest;
    fn to_proto(self) -> std::result::Result<CreateSessionRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            database: self.database.to_proto()?,
            session: self.session.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::CreateSessionRequest> for CreateSessionRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::CreateSessionRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::CreateSessionRequest::new()
                .set_database(self.database)
                .set_or_clear_session(self.session.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<BatchCreateSessionsRequest> for crate::generated::gapic_dataplane::model::BatchCreateSessionsRequest {
    type Output = BatchCreateSessionsRequest;
    fn to_proto(self) -> std::result::Result<BatchCreateSessionsRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            database: self.database.to_proto()?,
            session_template: self.session_template.map(|v| v.to_proto()).transpose()?,
            session_count: self.session_count.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::BatchCreateSessionsRequest> for BatchCreateSessionsRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::BatchCreateSessionsRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::BatchCreateSessionsRequest::new()
                .set_database(self.database)
                .set_or_clear_session_template(self.session_template.map(|v| v.cnv()).transpose()?)
                .set_session_count(self.session_count)
        )
    }
}

impl gaxi::prost::ToProto<BatchCreateSessionsResponse> for crate::generated::gapic_dataplane::model::BatchCreateSessionsResponse {
    type Output = BatchCreateSessionsResponse;
    fn to_proto(self) -> std::result::Result<BatchCreateSessionsResponse, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            session: self.session
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::BatchCreateSessionsResponse> for BatchCreateSessionsResponse {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::BatchCreateSessionsResponse, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::BatchCreateSessionsResponse::new()
                .set_session(self.session.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}

impl gaxi::prost::ToProto<Session> for crate::generated::gapic_dataplane::model::Session {
    type Output = Session;
    fn to_proto(self) -> std::result::Result<Session, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            name: self.name.to_proto()?,
            labels: self.labels
                .into_iter()
                .map(|(k, v)| {
                    gaxi::prost::pair_transpose(k.to_proto(), v.to_proto())
                }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            create_time: self.create_time.map(|v| v.to_proto()).transpose()?,
            approximate_last_use_time: self.approximate_last_use_time.map(|v| v.to_proto()).transpose()?,
            creator_role: self.creator_role.to_proto()?,
            multiplexed: self.multiplexed.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::Session> for Session {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::Session, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::Session::new()
                .set_name(self.name)
                .set_labels(self.labels.into_iter()
                    .map(|(k, v)| {
                        gaxi::prost::pair_transpose(k.cnv(), v.cnv())
                    }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?)
                .set_or_clear_create_time(self.create_time.map(|v| v.cnv()).transpose()?)
                .set_or_clear_approximate_last_use_time(self.approximate_last_use_time.map(|v| v.cnv()).transpose()?)
                .set_creator_role(self.creator_role)
                .set_multiplexed(self.multiplexed)
        )
    }
}

impl gaxi::prost::ToProto<GetSessionRequest> for crate::generated::gapic_dataplane::model::GetSessionRequest {
    type Output = GetSessionRequest;
    fn to_proto(self) -> std::result::Result<GetSessionRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            name: self.name.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::GetSessionRequest> for GetSessionRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::GetSessionRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::GetSessionRequest::new()
                .set_name(self.name)
        )
    }
}

impl gaxi::prost::ToProto<ListSessionsRequest> for crate::generated::gapic_dataplane::model::ListSessionsRequest {
    type Output = ListSessionsRequest;
    fn to_proto(self) -> std::result::Result<ListSessionsRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            database: self.database.to_proto()?,
            page_size: self.page_size.to_proto()?,
            page_token: self.page_token.to_proto()?,
            filter: self.filter.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::ListSessionsRequest> for ListSessionsRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::ListSessionsRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::ListSessionsRequest::new()
                .set_database(self.database)
                .set_page_size(self.page_size)
                .set_page_token(self.page_token)
                .set_filter(self.filter)
        )
    }
}

impl gaxi::prost::ToProto<ListSessionsResponse> for crate::generated::gapic_dataplane::model::ListSessionsResponse {
    type Output = ListSessionsResponse;
    fn to_proto(self) -> std::result::Result<ListSessionsResponse, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            sessions: self.sessions
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            next_page_token: self.next_page_token.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::ListSessionsResponse> for ListSessionsResponse {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::ListSessionsResponse, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::ListSessionsResponse::new()
                .set_sessions(self.sessions.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_next_page_token(self.next_page_token)
        )
    }
}

impl gaxi::prost::ToProto<DeleteSessionRequest> for crate::generated::gapic_dataplane::model::DeleteSessionRequest {
    type Output = DeleteSessionRequest;
    fn to_proto(self) -> std::result::Result<DeleteSessionRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            name: self.name.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::DeleteSessionRequest> for DeleteSessionRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::DeleteSessionRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::DeleteSessionRequest::new()
                .set_name(self.name)
        )
    }
}

impl gaxi::prost::ToProto<request_options::ClientContext> for crate::generated::gapic_dataplane::model::request_options::ClientContext {
    type Output = request_options::ClientContext;
    fn to_proto(self) -> std::result::Result<request_options::ClientContext, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            secure_context: self.secure_context
                .into_iter()
                .map(|(k, v)| {
                    gaxi::prost::pair_transpose(k.to_proto(), v.to_proto())
                }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::request_options::ClientContext> for request_options::ClientContext {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::request_options::ClientContext, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::request_options::ClientContext::new()
                .set_secure_context(self.secure_context.into_iter()
                    .map(|(k, v)| {
                        gaxi::prost::pair_transpose(k.cnv(), v.cnv())
                    }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?)
        )
    }
}

impl gaxi::prost::ToProto<request_options::Priority> for crate::generated::gapic_dataplane::model::request_options::Priority {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::request_options::Priority"))
    }
}

impl gaxi::prost::ToProto<RequestOptions> for crate::generated::gapic_dataplane::model::RequestOptions {
    type Output = RequestOptions;
    fn to_proto(self) -> std::result::Result<RequestOptions, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            priority: self.priority.to_proto()?,
            request_tag: self.request_tag.to_proto()?,
            transaction_tag: self.transaction_tag.to_proto()?,
            client_context: self.client_context.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::RequestOptions> for RequestOptions {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::RequestOptions, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::RequestOptions::new()
                .set_priority(self.priority)
                .set_request_tag(self.request_tag)
                .set_transaction_tag(self.transaction_tag)
                .set_or_clear_client_context(self.client_context.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<directed_read_options::replica_selection::Type> for crate::generated::gapic_dataplane::model::directed_read_options::replica_selection::Type {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::directed_read_options::replica_selection::Type"))
    }
}

impl gaxi::prost::ToProto<directed_read_options::ReplicaSelection> for crate::generated::gapic_dataplane::model::directed_read_options::ReplicaSelection {
    type Output = directed_read_options::ReplicaSelection;
    fn to_proto(self) -> std::result::Result<directed_read_options::ReplicaSelection, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            location: self.location.to_proto()?,
            r#type: self.r#type.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::directed_read_options::ReplicaSelection> for directed_read_options::ReplicaSelection {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::directed_read_options::ReplicaSelection, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::directed_read_options::ReplicaSelection::new()
                .set_location(self.location)
                .set_type(self.r#type)
        )
    }
}

impl gaxi::prost::ToProto<directed_read_options::IncludeReplicas> for crate::generated::gapic_dataplane::model::directed_read_options::IncludeReplicas {
    type Output = directed_read_options::IncludeReplicas;
    fn to_proto(self) -> std::result::Result<directed_read_options::IncludeReplicas, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            replica_selections: self.replica_selections
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            auto_failover_disabled: self.auto_failover_disabled.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::directed_read_options::IncludeReplicas> for directed_read_options::IncludeReplicas {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::directed_read_options::IncludeReplicas, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::directed_read_options::IncludeReplicas::new()
                .set_replica_selections(self.replica_selections.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_auto_failover_disabled(self.auto_failover_disabled)
        )
    }
}

impl gaxi::prost::ToProto<directed_read_options::ExcludeReplicas> for crate::generated::gapic_dataplane::model::directed_read_options::ExcludeReplicas {
    type Output = directed_read_options::ExcludeReplicas;
    fn to_proto(self) -> std::result::Result<directed_read_options::ExcludeReplicas, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            replica_selections: self.replica_selections
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::directed_read_options::ExcludeReplicas> for directed_read_options::ExcludeReplicas {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::directed_read_options::ExcludeReplicas, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::directed_read_options::ExcludeReplicas::new()
                .set_replica_selections(self.replica_selections.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}

impl gaxi::prost::ToProto<directed_read_options::Replicas> for crate::generated::gapic_dataplane::model::directed_read_options::Replicas {
    type Output = directed_read_options::Replicas;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::IncludeReplicas(v) => Ok(Self::Output::IncludeReplicas((*v).to_proto()?)),
            Self::ExcludeReplicas(v) => Ok(Self::Output::ExcludeReplicas((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::directed_read_options::Replicas> for directed_read_options::Replicas {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::directed_read_options::Replicas, gaxi::prost::ConvertError> {
        use crate::generated::gapic_dataplane::model::directed_read_options::Replicas as T;
        match self {
            Self::IncludeReplicas(v) => Ok(T::from_include_replicas(v.cnv()?)),
            Self::ExcludeReplicas(v) => Ok(T::from_exclude_replicas(v.cnv()?)),
        }
    }
}

impl gaxi::prost::ToProto<DirectedReadOptions> for crate::generated::gapic_dataplane::model::DirectedReadOptions {
    type Output = DirectedReadOptions;
    fn to_proto(self) -> std::result::Result<DirectedReadOptions, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            replicas: self.replicas.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::DirectedReadOptions> for DirectedReadOptions {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::DirectedReadOptions, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::DirectedReadOptions::new()
                .set_replicas(self.replicas.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<execute_sql_request::QueryOptions> for crate::generated::gapic_dataplane::model::execute_sql_request::QueryOptions {
    type Output = execute_sql_request::QueryOptions;
    fn to_proto(self) -> std::result::Result<execute_sql_request::QueryOptions, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            optimizer_version: self.optimizer_version.to_proto()?,
            optimizer_statistics_package: self.optimizer_statistics_package.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::execute_sql_request::QueryOptions> for execute_sql_request::QueryOptions {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::execute_sql_request::QueryOptions, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::execute_sql_request::QueryOptions::new()
                .set_optimizer_version(self.optimizer_version)
                .set_optimizer_statistics_package(self.optimizer_statistics_package)
        )
    }
}

impl gaxi::prost::ToProto<execute_sql_request::QueryMode> for crate::generated::gapic_dataplane::model::execute_sql_request::QueryMode {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::execute_sql_request::QueryMode"))
    }
}

impl gaxi::prost::ToProto<ExecuteSqlRequest> for crate::generated::gapic_dataplane::model::ExecuteSqlRequest {
    type Output = ExecuteSqlRequest;
    fn to_proto(self) -> std::result::Result<ExecuteSqlRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            session: self.session.to_proto()?,
            transaction: self.transaction.map(|v| v.to_proto()).transpose()?,
            sql: self.sql.to_proto()?,
            params: self.params.map(|v| v.to_proto()).transpose()?,
            param_types: self.param_types
                .into_iter()
                .map(|(k, v)| {
                    gaxi::prost::pair_transpose(k.to_proto(), v.to_proto())
                }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            resume_token: self.resume_token.to_proto()?,
            query_mode: self.query_mode.to_proto()?,
            partition_token: self.partition_token.to_proto()?,
            seqno: self.seqno.to_proto()?,
            query_options: self.query_options.map(|v| v.to_proto()).transpose()?,
            request_options: self.request_options.map(|v| v.to_proto()).transpose()?,
            directed_read_options: self.directed_read_options.map(|v| v.to_proto()).transpose()?,
            data_boost_enabled: self.data_boost_enabled.to_proto()?,
            last_statement: self.last_statement.to_proto()?,
            routing_hint: self.routing_hint.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::ExecuteSqlRequest> for ExecuteSqlRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::ExecuteSqlRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::ExecuteSqlRequest::new()
                .set_session(self.session)
                .set_or_clear_transaction(self.transaction.map(|v| v.cnv()).transpose()?)
                .set_sql(self.sql)
                .set_or_clear_params(self.params.map(|v| v.cnv()).transpose()?)
                .set_param_types(self.param_types.into_iter()
                    .map(|(k, v)| {
                        gaxi::prost::pair_transpose(k.cnv(), v.cnv())
                    }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?)
                .set_resume_token(self.resume_token)
                .set_query_mode(self.query_mode)
                .set_partition_token(self.partition_token)
                .set_seqno(self.seqno)
                .set_or_clear_query_options(self.query_options.map(|v| v.cnv()).transpose()?)
                .set_or_clear_request_options(self.request_options.map(|v| v.cnv()).transpose()?)
                .set_or_clear_directed_read_options(self.directed_read_options.map(|v| v.cnv()).transpose()?)
                .set_data_boost_enabled(self.data_boost_enabled)
                .set_last_statement(self.last_statement)
                .set_or_clear_routing_hint(self.routing_hint.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<execute_batch_dml_request::Statement> for crate::generated::gapic_dataplane::model::execute_batch_dml_request::Statement {
    type Output = execute_batch_dml_request::Statement;
    fn to_proto(self) -> std::result::Result<execute_batch_dml_request::Statement, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            sql: self.sql.to_proto()?,
            params: self.params.map(|v| v.to_proto()).transpose()?,
            param_types: self.param_types
                .into_iter()
                .map(|(k, v)| {
                    gaxi::prost::pair_transpose(k.to_proto(), v.to_proto())
                }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::execute_batch_dml_request::Statement> for execute_batch_dml_request::Statement {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::execute_batch_dml_request::Statement, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::execute_batch_dml_request::Statement::new()
                .set_sql(self.sql)
                .set_or_clear_params(self.params.map(|v| v.cnv()).transpose()?)
                .set_param_types(self.param_types.into_iter()
                    .map(|(k, v)| {
                        gaxi::prost::pair_transpose(k.cnv(), v.cnv())
                    }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?)
        )
    }
}

impl gaxi::prost::ToProto<ExecuteBatchDmlRequest> for crate::generated::gapic_dataplane::model::ExecuteBatchDmlRequest {
    type Output = ExecuteBatchDmlRequest;
    fn to_proto(self) -> std::result::Result<ExecuteBatchDmlRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            session: self.session.to_proto()?,
            transaction: self.transaction.map(|v| v.to_proto()).transpose()?,
            statements: self.statements
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            seqno: self.seqno.to_proto()?,
            request_options: self.request_options.map(|v| v.to_proto()).transpose()?,
            last_statements: self.last_statements.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::ExecuteBatchDmlRequest> for ExecuteBatchDmlRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::ExecuteBatchDmlRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::ExecuteBatchDmlRequest::new()
                .set_session(self.session)
                .set_or_clear_transaction(self.transaction.map(|v| v.cnv()).transpose()?)
                .set_statements(self.statements.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_seqno(self.seqno)
                .set_or_clear_request_options(self.request_options.map(|v| v.cnv()).transpose()?)
                .set_last_statements(self.last_statements)
        )
    }
}

impl gaxi::prost::ToProto<ExecuteBatchDmlResponse> for crate::generated::gapic_dataplane::model::ExecuteBatchDmlResponse {
    type Output = ExecuteBatchDmlResponse;
    fn to_proto(self) -> std::result::Result<ExecuteBatchDmlResponse, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            result_sets: self.result_sets
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            status: self.status.map(|v| v.to_proto()).transpose()?,
            precommit_token: self.precommit_token.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::ExecuteBatchDmlResponse> for ExecuteBatchDmlResponse {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::ExecuteBatchDmlResponse, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::ExecuteBatchDmlResponse::new()
                .set_result_sets(self.result_sets.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_or_clear_status(self.status.map(|v| v.cnv()).transpose()?)
                .set_or_clear_precommit_token(self.precommit_token.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<PartitionOptions> for crate::generated::gapic_dataplane::model::PartitionOptions {
    type Output = PartitionOptions;
    fn to_proto(self) -> std::result::Result<PartitionOptions, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            partition_size_bytes: self.partition_size_bytes.to_proto()?,
            max_partitions: self.max_partitions.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::PartitionOptions> for PartitionOptions {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::PartitionOptions, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::PartitionOptions::new()
                .set_partition_size_bytes(self.partition_size_bytes)
                .set_max_partitions(self.max_partitions)
        )
    }
}

impl gaxi::prost::ToProto<PartitionQueryRequest> for crate::generated::gapic_dataplane::model::PartitionQueryRequest {
    type Output = PartitionQueryRequest;
    fn to_proto(self) -> std::result::Result<PartitionQueryRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            session: self.session.to_proto()?,
            transaction: self.transaction.map(|v| v.to_proto()).transpose()?,
            sql: self.sql.to_proto()?,
            params: self.params.map(|v| v.to_proto()).transpose()?,
            param_types: self.param_types
                .into_iter()
                .map(|(k, v)| {
                    gaxi::prost::pair_transpose(k.to_proto(), v.to_proto())
                }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            partition_options: self.partition_options.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::PartitionQueryRequest> for PartitionQueryRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::PartitionQueryRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::PartitionQueryRequest::new()
                .set_session(self.session)
                .set_or_clear_transaction(self.transaction.map(|v| v.cnv()).transpose()?)
                .set_sql(self.sql)
                .set_or_clear_params(self.params.map(|v| v.cnv()).transpose()?)
                .set_param_types(self.param_types.into_iter()
                    .map(|(k, v)| {
                        gaxi::prost::pair_transpose(k.cnv(), v.cnv())
                    }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?)
                .set_or_clear_partition_options(self.partition_options.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<PartitionReadRequest> for crate::generated::gapic_dataplane::model::PartitionReadRequest {
    type Output = PartitionReadRequest;
    fn to_proto(self) -> std::result::Result<PartitionReadRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            session: self.session.to_proto()?,
            transaction: self.transaction.map(|v| v.to_proto()).transpose()?,
            table: self.table.to_proto()?,
            index: self.index.to_proto()?,
            columns: self.columns
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            key_set: self.key_set.map(|v| v.to_proto()).transpose()?,
            partition_options: self.partition_options.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::PartitionReadRequest> for PartitionReadRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::PartitionReadRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::PartitionReadRequest::new()
                .set_session(self.session)
                .set_or_clear_transaction(self.transaction.map(|v| v.cnv()).transpose()?)
                .set_table(self.table)
                .set_index(self.index)
                .set_columns(self.columns.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_or_clear_key_set(self.key_set.map(|v| v.cnv()).transpose()?)
                .set_or_clear_partition_options(self.partition_options.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<Partition> for crate::generated::gapic_dataplane::model::Partition {
    type Output = Partition;
    fn to_proto(self) -> std::result::Result<Partition, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            partition_token: self.partition_token.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::Partition> for Partition {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::Partition, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::Partition::new()
                .set_partition_token(self.partition_token)
        )
    }
}

impl gaxi::prost::ToProto<PartitionResponse> for crate::generated::gapic_dataplane::model::PartitionResponse {
    type Output = PartitionResponse;
    fn to_proto(self) -> std::result::Result<PartitionResponse, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            partitions: self.partitions
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            transaction: self.transaction.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::PartitionResponse> for PartitionResponse {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::PartitionResponse, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::PartitionResponse::new()
                .set_partitions(self.partitions.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_or_clear_transaction(self.transaction.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<read_request::OrderBy> for crate::generated::gapic_dataplane::model::read_request::OrderBy {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::read_request::OrderBy"))
    }
}

impl gaxi::prost::ToProto<read_request::LockHint> for crate::generated::gapic_dataplane::model::read_request::LockHint {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::read_request::LockHint"))
    }
}

impl gaxi::prost::ToProto<ReadRequest> for crate::generated::gapic_dataplane::model::ReadRequest {
    type Output = ReadRequest;
    fn to_proto(self) -> std::result::Result<ReadRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            session: self.session.to_proto()?,
            transaction: self.transaction.map(|v| v.to_proto()).transpose()?,
            table: self.table.to_proto()?,
            index: self.index.to_proto()?,
            columns: self.columns
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            key_set: self.key_set.map(|v| v.to_proto()).transpose()?,
            limit: self.limit.to_proto()?,
            resume_token: self.resume_token.to_proto()?,
            partition_token: self.partition_token.to_proto()?,
            request_options: self.request_options.map(|v| v.to_proto()).transpose()?,
            directed_read_options: self.directed_read_options.map(|v| v.to_proto()).transpose()?,
            data_boost_enabled: self.data_boost_enabled.to_proto()?,
            order_by: self.order_by.to_proto()?,
            lock_hint: self.lock_hint.to_proto()?,
            routing_hint: self.routing_hint.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::ReadRequest> for ReadRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::ReadRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::ReadRequest::new()
                .set_session(self.session)
                .set_or_clear_transaction(self.transaction.map(|v| v.cnv()).transpose()?)
                .set_table(self.table)
                .set_index(self.index)
                .set_columns(self.columns.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_or_clear_key_set(self.key_set.map(|v| v.cnv()).transpose()?)
                .set_limit(self.limit)
                .set_resume_token(self.resume_token)
                .set_partition_token(self.partition_token)
                .set_or_clear_request_options(self.request_options.map(|v| v.cnv()).transpose()?)
                .set_or_clear_directed_read_options(self.directed_read_options.map(|v| v.cnv()).transpose()?)
                .set_data_boost_enabled(self.data_boost_enabled)
                .set_order_by(self.order_by)
                .set_lock_hint(self.lock_hint)
                .set_or_clear_routing_hint(self.routing_hint.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<BeginTransactionRequest> for crate::generated::gapic_dataplane::model::BeginTransactionRequest {
    type Output = BeginTransactionRequest;
    fn to_proto(self) -> std::result::Result<BeginTransactionRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            session: self.session.to_proto()?,
            options: self.options.map(|v| v.to_proto()).transpose()?,
            request_options: self.request_options.map(|v| v.to_proto()).transpose()?,
            mutation_key: self.mutation_key.map(|v| v.to_proto()).transpose()?,
            routing_hint: self.routing_hint.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::BeginTransactionRequest> for BeginTransactionRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::BeginTransactionRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::BeginTransactionRequest::new()
                .set_session(self.session)
                .set_or_clear_options(self.options.map(|v| v.cnv()).transpose()?)
                .set_or_clear_request_options(self.request_options.map(|v| v.cnv()).transpose()?)
                .set_or_clear_mutation_key(self.mutation_key.map(|v| v.cnv()).transpose()?)
                .set_or_clear_routing_hint(self.routing_hint.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<commit_request::Transaction> for crate::generated::gapic_dataplane::model::commit_request::Transaction {
    type Output = commit_request::Transaction;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::TransactionId(v) => Ok(Self::Output::TransactionId(v.to_proto()?)),
            Self::SingleUseTransaction(v) => Ok(Self::Output::SingleUseTransaction((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::commit_request::Transaction> for commit_request::Transaction {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::commit_request::Transaction, gaxi::prost::ConvertError> {
        use crate::generated::gapic_dataplane::model::commit_request::Transaction as T;
        match self {
            Self::TransactionId(v) => Ok(T::from_transaction_id(v.cnv()?)),
            Self::SingleUseTransaction(v) => Ok(T::from_single_use_transaction(v.cnv()?)),
        }
    }
}

impl gaxi::prost::ToProto<CommitRequest> for crate::generated::gapic_dataplane::model::CommitRequest {
    type Output = CommitRequest;
    fn to_proto(self) -> std::result::Result<CommitRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            session: self.session.to_proto()?,
            mutations: self.mutations
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            return_commit_stats: self.return_commit_stats.to_proto()?,
            max_commit_delay: self.max_commit_delay.map(|v| v.to_proto()).transpose()?,
            request_options: self.request_options.map(|v| v.to_proto()).transpose()?,
            precommit_token: self.precommit_token.map(|v| v.to_proto()).transpose()?,
            routing_hint: self.routing_hint.map(|v| v.to_proto()).transpose()?,
            transaction: self.transaction.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::CommitRequest> for CommitRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::CommitRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::CommitRequest::new()
                .set_session(self.session)
                .set_mutations(self.mutations.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_return_commit_stats(self.return_commit_stats)
                .set_or_clear_max_commit_delay(self.max_commit_delay.map(|v| v.cnv()).transpose()?)
                .set_or_clear_request_options(self.request_options.map(|v| v.cnv()).transpose()?)
                .set_or_clear_precommit_token(self.precommit_token.map(|v| v.cnv()).transpose()?)
                .set_or_clear_routing_hint(self.routing_hint.map(|v| v.cnv()).transpose()?)
                .set_transaction(self.transaction.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<RollbackRequest> for crate::generated::gapic_dataplane::model::RollbackRequest {
    type Output = RollbackRequest;
    fn to_proto(self) -> std::result::Result<RollbackRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            session: self.session.to_proto()?,
            transaction_id: self.transaction_id.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::RollbackRequest> for RollbackRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::RollbackRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::RollbackRequest::new()
                .set_session(self.session)
                .set_transaction_id(self.transaction_id)
        )
    }
}

impl gaxi::prost::ToProto<batch_write_request::MutationGroup> for crate::generated::gapic_dataplane::model::batch_write_request::MutationGroup {
    type Output = batch_write_request::MutationGroup;
    fn to_proto(self) -> std::result::Result<batch_write_request::MutationGroup, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            mutations: self.mutations
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::batch_write_request::MutationGroup> for batch_write_request::MutationGroup {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::batch_write_request::MutationGroup, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::batch_write_request::MutationGroup::new()
                .set_mutations(self.mutations.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}

impl gaxi::prost::ToProto<BatchWriteRequest> for crate::generated::gapic_dataplane::model::BatchWriteRequest {
    type Output = BatchWriteRequest;
    fn to_proto(self) -> std::result::Result<BatchWriteRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            session: self.session.to_proto()?,
            request_options: self.request_options.map(|v| v.to_proto()).transpose()?,
            mutation_groups: self.mutation_groups
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            exclude_txn_from_change_streams: self.exclude_txn_from_change_streams.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::BatchWriteRequest> for BatchWriteRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::BatchWriteRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::BatchWriteRequest::new()
                .set_session(self.session)
                .set_or_clear_request_options(self.request_options.map(|v| v.cnv()).transpose()?)
                .set_mutation_groups(self.mutation_groups.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_exclude_txn_from_change_streams(self.exclude_txn_from_change_streams)
        )
    }
}

impl gaxi::prost::ToProto<BatchWriteResponse> for crate::generated::gapic_dataplane::model::BatchWriteResponse {
    type Output = BatchWriteResponse;
    fn to_proto(self) -> std::result::Result<BatchWriteResponse, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            indexes: self.indexes
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            status: self.status.map(|v| v.to_proto()).transpose()?,
            commit_timestamp: self.commit_timestamp.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::BatchWriteResponse> for BatchWriteResponse {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::BatchWriteResponse, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::BatchWriteResponse::new()
                .set_indexes(self.indexes.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_or_clear_status(self.status.map(|v| v.cnv()).transpose()?)
                .set_or_clear_commit_timestamp(self.commit_timestamp.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<FetchCacheUpdateRequest> for crate::generated::gapic_dataplane::model::FetchCacheUpdateRequest {
    type Output = FetchCacheUpdateRequest;
    fn to_proto(self) -> std::result::Result<FetchCacheUpdateRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            database: self.database.to_proto()?,
            max_recipe_count: self.max_recipe_count.to_proto()?,
            max_range_count: self.max_range_count.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::FetchCacheUpdateRequest> for FetchCacheUpdateRequest {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::FetchCacheUpdateRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::FetchCacheUpdateRequest::new()
                .set_database(self.database)
                .set_max_recipe_count(self.max_recipe_count)
                .set_max_range_count(self.max_range_count)
        )
    }
}

impl gaxi::prost::ToProto<transaction_options::read_write::ReadLockMode> for crate::generated::gapic_dataplane::model::transaction_options::read_write::ReadLockMode {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::transaction_options::read_write::ReadLockMode"))
    }
}

impl gaxi::prost::ToProto<transaction_options::ReadWrite> for crate::generated::gapic_dataplane::model::transaction_options::ReadWrite {
    type Output = transaction_options::ReadWrite;
    fn to_proto(self) -> std::result::Result<transaction_options::ReadWrite, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            read_lock_mode: self.read_lock_mode.to_proto()?,
            multiplexed_session_previous_transaction_id: self.multiplexed_session_previous_transaction_id.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::transaction_options::ReadWrite> for transaction_options::ReadWrite {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::transaction_options::ReadWrite, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::transaction_options::ReadWrite::new()
                .set_read_lock_mode(self.read_lock_mode)
                .set_multiplexed_session_previous_transaction_id(self.multiplexed_session_previous_transaction_id)
        )
    }
}

impl gaxi::prost::ToProto<transaction_options::PartitionedDml> for crate::generated::gapic_dataplane::model::transaction_options::PartitionedDml {
    type Output = transaction_options::PartitionedDml;
    fn to_proto(self) -> std::result::Result<transaction_options::PartitionedDml, gaxi::prost::ConvertError> {
        Ok(Self::Output {
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::transaction_options::PartitionedDml> for transaction_options::PartitionedDml {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::transaction_options::PartitionedDml, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::transaction_options::PartitionedDml::new()
        )
    }
}

impl gaxi::prost::ToProto<transaction_options::read_only::TimestampBound> for crate::generated::gapic_dataplane::model::transaction_options::read_only::TimestampBound {
    type Output = transaction_options::read_only::TimestampBound;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::Strong(v) => Ok(Self::Output::Strong(v.to_proto()?)),
            Self::MinReadTimestamp(v) => Ok(Self::Output::MinReadTimestamp((*v).to_proto()?)),
            Self::MaxStaleness(v) => Ok(Self::Output::MaxStaleness((*v).to_proto()?)),
            Self::ReadTimestamp(v) => Ok(Self::Output::ReadTimestamp((*v).to_proto()?)),
            Self::ExactStaleness(v) => Ok(Self::Output::ExactStaleness((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::transaction_options::read_only::TimestampBound> for transaction_options::read_only::TimestampBound {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::transaction_options::read_only::TimestampBound, gaxi::prost::ConvertError> {
        use crate::generated::gapic_dataplane::model::transaction_options::read_only::TimestampBound as T;
        match self {
            Self::Strong(v) => Ok(T::from_strong(v.cnv()?)),
            Self::MinReadTimestamp(v) => Ok(T::from_min_read_timestamp(v.cnv()?)),
            Self::MaxStaleness(v) => Ok(T::from_max_staleness(v.cnv()?)),
            Self::ReadTimestamp(v) => Ok(T::from_read_timestamp(v.cnv()?)),
            Self::ExactStaleness(v) => Ok(T::from_exact_staleness(v.cnv()?)),
        }
    }
}

impl gaxi::prost::ToProto<transaction_options::ReadOnly> for crate::generated::gapic_dataplane::model::transaction_options::ReadOnly {
    type Output = transaction_options::ReadOnly;
    fn to_proto(self) -> std::result::Result<transaction_options::ReadOnly, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            return_read_timestamp: self.return_read_timestamp.to_proto()?,
            timestamp_bound: self.timestamp_bound.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::transaction_options::ReadOnly> for transaction_options::ReadOnly {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::transaction_options::ReadOnly, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::transaction_options::ReadOnly::new()
                .set_return_read_timestamp(self.return_read_timestamp)
                .set_timestamp_bound(self.timestamp_bound.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<transaction_options::IsolationLevel> for crate::generated::gapic_dataplane::model::transaction_options::IsolationLevel {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::generated::gapic_dataplane::model::transaction_options::IsolationLevel"))
    }
}

impl gaxi::prost::ToProto<transaction_options::Mode> for crate::generated::gapic_dataplane::model::transaction_options::Mode {
    type Output = transaction_options::Mode;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::ReadWrite(v) => Ok(Self::Output::ReadWrite((*v).to_proto()?)),
            Self::PartitionedDml(v) => Ok(Self::Output::PartitionedDml((*v).to_proto()?)),
            Self::ReadOnly(v) => Ok(Self::Output::ReadOnly((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::transaction_options::Mode> for transaction_options::Mode {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::transaction_options::Mode, gaxi::prost::ConvertError> {
        use crate::generated::gapic_dataplane::model::transaction_options::Mode as T;
        match self {
            Self::ReadWrite(v) => Ok(T::from_read_write(v.cnv()?)),
            Self::PartitionedDml(v) => Ok(T::from_partitioned_dml(v.cnv()?)),
            Self::ReadOnly(v) => Ok(T::from_read_only(v.cnv()?)),
        }
    }
}

impl gaxi::prost::ToProto<TransactionOptions> for crate::generated::gapic_dataplane::model::TransactionOptions {
    type Output = TransactionOptions;
    fn to_proto(self) -> std::result::Result<TransactionOptions, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            exclude_txn_from_change_streams: self.exclude_txn_from_change_streams.to_proto()?,
            isolation_level: self.isolation_level.to_proto()?,
            mode: self.mode.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::TransactionOptions> for TransactionOptions {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::TransactionOptions, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::TransactionOptions::new()
                .set_exclude_txn_from_change_streams(self.exclude_txn_from_change_streams)
                .set_isolation_level(self.isolation_level)
                .set_mode(self.mode.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<Transaction> for crate::generated::gapic_dataplane::model::Transaction {
    type Output = Transaction;
    fn to_proto(self) -> std::result::Result<Transaction, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            id: self.id.to_proto()?,
            read_timestamp: self.read_timestamp.map(|v| v.to_proto()).transpose()?,
            precommit_token: self.precommit_token.map(|v| v.to_proto()).transpose()?,
            cache_update: self.cache_update.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::Transaction> for Transaction {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::Transaction, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::Transaction::new()
                .set_id(self.id)
                .set_or_clear_read_timestamp(self.read_timestamp.map(|v| v.cnv()).transpose()?)
                .set_or_clear_precommit_token(self.precommit_token.map(|v| v.cnv()).transpose()?)
                .set_or_clear_cache_update(self.cache_update.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<transaction_selector::Selector> for crate::generated::gapic_dataplane::model::transaction_selector::Selector {
    type Output = transaction_selector::Selector;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::SingleUse(v) => Ok(Self::Output::SingleUse((*v).to_proto()?)),
            Self::Id(v) => Ok(Self::Output::Id(v.to_proto()?)),
            Self::Begin(v) => Ok(Self::Output::Begin((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::transaction_selector::Selector> for transaction_selector::Selector {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::transaction_selector::Selector, gaxi::prost::ConvertError> {
        use crate::generated::gapic_dataplane::model::transaction_selector::Selector as T;
        match self {
            Self::SingleUse(v) => Ok(T::from_single_use(v.cnv()?)),
            Self::Id(v) => Ok(T::from_id(v.cnv()?)),
            Self::Begin(v) => Ok(T::from_begin(v.cnv()?)),
        }
    }
}

impl gaxi::prost::ToProto<TransactionSelector> for crate::generated::gapic_dataplane::model::TransactionSelector {
    type Output = TransactionSelector;
    fn to_proto(self) -> std::result::Result<TransactionSelector, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            selector: self.selector.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::TransactionSelector> for TransactionSelector {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::TransactionSelector, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::TransactionSelector::new()
                .set_selector(self.selector.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<MultiplexedSessionPrecommitToken> for crate::generated::gapic_dataplane::model::MultiplexedSessionPrecommitToken {
    type Output = MultiplexedSessionPrecommitToken;
    fn to_proto(self) -> std::result::Result<MultiplexedSessionPrecommitToken, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            precommit_token: self.precommit_token.to_proto()?,
            seq_num: self.seq_num.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::MultiplexedSessionPrecommitToken> for MultiplexedSessionPrecommitToken {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::MultiplexedSessionPrecommitToken, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::MultiplexedSessionPrecommitToken::new()
                .set_precommit_token(self.precommit_token)
                .set_seq_num(self.seq_num)
        )
    }
}

impl gaxi::prost::ToProto<Type> for crate::generated::gapic_dataplane::model::Type {
    type Output = Type;
    fn to_proto(self) -> std::result::Result<Type, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            code: self.code.to_proto()?,
            array_element_type: self.array_element_type.map(|v| v.to_proto().map(std::boxed::Box::new)).transpose()?,
            struct_type: self.struct_type.map(|v| v.to_proto()).transpose()?,
            type_annotation: self.type_annotation.to_proto()?,
            proto_type_fqn: self.proto_type_fqn.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::Type> for Type {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::Type, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::Type::new()
                .set_code(self.code)
                .set_or_clear_array_element_type(self.array_element_type.map(|v| v.cnv()).transpose()?)
                .set_or_clear_struct_type(self.struct_type.map(|v| v.cnv()).transpose()?)
                .set_type_annotation(self.type_annotation)
                .set_proto_type_fqn(self.proto_type_fqn)
        )
    }
}

impl gaxi::prost::ToProto<struct_type::Field> for crate::generated::gapic_dataplane::model::struct_type::Field {
    type Output = struct_type::Field;
    fn to_proto(self) -> std::result::Result<struct_type::Field, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            name: self.name.to_proto()?,
            r#type: self.r#type.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::struct_type::Field> for struct_type::Field {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::struct_type::Field, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::struct_type::Field::new()
                .set_name(self.name)
                .set_or_clear_type(self.r#type.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<StructType> for crate::generated::gapic_dataplane::model::StructType {
    type Output = StructType;
    fn to_proto(self) -> std::result::Result<StructType, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            fields: self.fields
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::generated::gapic_dataplane::model::StructType> for StructType {
    fn cnv(self) -> std::result::Result<crate::generated::gapic_dataplane::model::StructType, gaxi::prost::ConvertError> {
        Ok(
            crate::generated::gapic_dataplane::model::StructType::new()
                .set_fields(self.fields.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}