google-cloud-bigquery 0.17.0-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<DataFormat> for crate::write::generated::gapic_storage::model::DataFormat {
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value().ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue("crate::write::generated::gapic_storage::model::DataFormat"))
    }
}

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

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::ArrowSchema> for ArrowSchema {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::ArrowSchema, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::ArrowSchema::new()
                .set_serialized_schema(self.serialized_schema)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::ArrowRecordBatch> for ArrowRecordBatch {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::ArrowRecordBatch, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::ArrowRecordBatch::new()
                .set_serialized_record_batch(self.serialized_record_batch)
                .set_row_count(self.row_count)
        )
    }
}

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

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

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::ArrowSerializationOptions> for ArrowSerializationOptions {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::ArrowSerializationOptions, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::ArrowSerializationOptions::new()
                .set_buffer_compression(self.buffer_compression)
                .set_picos_timestamp_precision(self.picos_timestamp_precision)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::AvroSchema> for AvroSchema {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::AvroSchema, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::AvroSchema::new()
                .set_schema(self.schema)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::AvroRows> for AvroRows {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::AvroRows, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::AvroRows::new()
                .set_serialized_binary_rows(self.serialized_binary_rows)
                .set_row_count(self.row_count)
        )
    }
}

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

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::AvroSerializationOptions> for AvroSerializationOptions {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::AvroSerializationOptions, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::AvroSerializationOptions::new()
                .set_enable_display_name_attribute(self.enable_display_name_attribute)
                .set_picos_timestamp_precision(self.picos_timestamp_precision)
        )
    }
}

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

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

impl gaxi::prost::ToProto<CreateReadSessionRequest> for crate::write::generated::gapic_storage::model::CreateReadSessionRequest {
    type Output = CreateReadSessionRequest;
    fn to_proto(self) -> std::result::Result<CreateReadSessionRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            parent: self.parent.to_proto()?,
            read_session: self.read_session.map(|v| v.to_proto()).transpose()?,
            max_stream_count: self.max_stream_count.to_proto()?,
            preferred_min_stream_count: self.preferred_min_stream_count.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::CreateReadSessionRequest> for CreateReadSessionRequest {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::CreateReadSessionRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::CreateReadSessionRequest::new()
                .set_parent(self.parent)
                .set_or_clear_read_session(self.read_session.map(|v| v.cnv()).transpose()?)
                .set_max_stream_count(self.max_stream_count)
                .set_preferred_min_stream_count(self.preferred_min_stream_count)
        )
    }
}

impl gaxi::prost::ToProto<read_rows_request::OutputFormatSerializationOptions> for crate::write::generated::gapic_storage::model::read_rows_request::OutputFormatSerializationOptions {
    type Output = read_rows_request::OutputFormatSerializationOptions;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::ArrowSerializationOptions(v) => Ok(Self::Output::ArrowSerializationOptions((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::read_rows_request::OutputFormatSerializationOptions> for read_rows_request::OutputFormatSerializationOptions {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::read_rows_request::OutputFormatSerializationOptions, gaxi::prost::ConvertError> {
        use crate::write::generated::gapic_storage::model::read_rows_request::OutputFormatSerializationOptions as T;
        match self {
            Self::ArrowSerializationOptions(v) => Ok(T::ArrowSerializationOptions(std::boxed::Box::new(v.cnv()?))),
        }
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::ReadRowsRequest> for ReadRowsRequest {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::ReadRowsRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::ReadRowsRequest::new()
                .set_read_stream(self.read_stream)
                .set_offset(self.offset)
                .set_output_format_serialization_options(self.output_format_serialization_options.map(|v| v.cnv()).transpose()?)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::ThrottleState> for ThrottleState {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::ThrottleState, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::ThrottleState::new()
                .set_throttle_percent(self.throttle_percent)
        )
    }
}

impl gaxi::prost::ToProto<stream_stats::Progress> for crate::write::generated::gapic_storage::model::stream_stats::Progress {
    type Output = stream_stats::Progress;
    fn to_proto(self) -> std::result::Result<stream_stats::Progress, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            at_response_start: self.at_response_start.to_proto()?,
            at_response_end: self.at_response_end.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::stream_stats::Progress> for stream_stats::Progress {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::stream_stats::Progress, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::stream_stats::Progress::new()
                .set_at_response_start(self.at_response_start)
                .set_at_response_end(self.at_response_end)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::StreamStats> for StreamStats {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::StreamStats, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::StreamStats::new()
                .set_or_clear_progress(self.progress.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<read_rows_response::Rows> for crate::write::generated::gapic_storage::model::read_rows_response::Rows {
    type Output = read_rows_response::Rows;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::AvroRows(v) => Ok(Self::Output::AvroRows((*v).to_proto()?)),
            Self::ArrowRecordBatch(v) => Ok(Self::Output::ArrowRecordBatch((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::read_rows_response::Rows> for read_rows_response::Rows {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::read_rows_response::Rows, gaxi::prost::ConvertError> {
        use crate::write::generated::gapic_storage::model::read_rows_response::Rows as T;
        match self {
            Self::AvroRows(v) => Ok(T::AvroRows(std::boxed::Box::new(v.cnv()?))),
            Self::ArrowRecordBatch(v) => Ok(T::ArrowRecordBatch(std::boxed::Box::new(v.cnv()?))),
        }
    }
}

impl gaxi::prost::ToProto<read_rows_response::Schema> for crate::write::generated::gapic_storage::model::read_rows_response::Schema {
    type Output = read_rows_response::Schema;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::AvroSchema(v) => Ok(Self::Output::AvroSchema((*v).to_proto()?)),
            Self::ArrowSchema(v) => Ok(Self::Output::ArrowSchema((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::read_rows_response::Schema> for read_rows_response::Schema {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::read_rows_response::Schema, gaxi::prost::ConvertError> {
        use crate::write::generated::gapic_storage::model::read_rows_response::Schema as T;
        match self {
            Self::AvroSchema(v) => Ok(T::AvroSchema(std::boxed::Box::new(v.cnv()?))),
            Self::ArrowSchema(v) => Ok(T::ArrowSchema(std::boxed::Box::new(v.cnv()?))),
        }
    }
}

impl gaxi::prost::ToProto<ReadRowsResponse> for crate::write::generated::gapic_storage::model::ReadRowsResponse {
    type Output = ReadRowsResponse;
    fn to_proto(self) -> std::result::Result<ReadRowsResponse, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            row_count: self.row_count.to_proto()?,
            stats: self.stats.map(|v| v.to_proto()).transpose()?,
            throttle_state: self.throttle_state.map(|v| v.to_proto()).transpose()?,
            uncompressed_byte_size: self.uncompressed_byte_size.map(|v| v.to_proto()).transpose()?,
            total_estimated_row_count: self.total_estimated_row_count.map(|v| v.to_proto()).transpose()?,
            rows: self.rows.map(|v| v.to_proto()).transpose()?,
            schema: self.schema.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::ReadRowsResponse> for ReadRowsResponse {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::ReadRowsResponse, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::ReadRowsResponse::new()
                .set_row_count(self.row_count)
                .set_or_clear_stats(self.stats.map(|v| v.cnv()).transpose()?)
                .set_or_clear_throttle_state(self.throttle_state.map(|v| v.cnv()).transpose()?)
                .set_or_clear_uncompressed_byte_size(self.uncompressed_byte_size.map(|v| v.cnv()).transpose()?)
                .set_or_clear_total_estimated_row_count(self.total_estimated_row_count.map(|v| v.cnv()).transpose()?)
                .set_rows(self.rows.map(|v| v.cnv()).transpose()?)
                .set_schema(self.schema.map(|v| v.cnv()).transpose()?)
        )
    }
}

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

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

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::SplitReadStreamResponse> for SplitReadStreamResponse {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::SplitReadStreamResponse, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::SplitReadStreamResponse::new()
                .set_or_clear_primary_stream(self.primary_stream.map(|v| v.cnv()).transpose()?)
                .set_or_clear_remainder_stream(self.remainder_stream.map(|v| v.cnv()).transpose()?)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::CreateWriteStreamRequest> for CreateWriteStreamRequest {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::CreateWriteStreamRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::CreateWriteStreamRequest::new()
                .set_parent(self.parent)
                .set_or_clear_write_stream(self.write_stream.map(|v| v.cnv()).transpose()?)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::append_rows_request::ArrowData> for append_rows_request::ArrowData {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::append_rows_request::ArrowData, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::append_rows_request::ArrowData::new()
                .set_or_clear_writer_schema(self.writer_schema.map(|v| v.cnv()).transpose()?)
                .set_or_clear_rows(self.rows.map(|v| v.cnv()).transpose()?)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::append_rows_request::ProtoData> for append_rows_request::ProtoData {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::append_rows_request::ProtoData, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::append_rows_request::ProtoData::new()
                .set_or_clear_writer_schema(self.writer_schema.map(|v| v.cnv()).transpose()?)
                .set_or_clear_rows(self.rows.map(|v| v.cnv()).transpose()?)
        )
    }
}

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

impl gaxi::prost::ToProto<append_rows_request::Rows> for crate::write::generated::gapic_storage::model::append_rows_request::Rows {
    type Output = append_rows_request::Rows;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::ProtoRows(v) => Ok(Self::Output::ProtoRows((*v).to_proto()?)),
            Self::ArrowRows(v) => Ok(Self::Output::ArrowRows((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::append_rows_request::Rows> for append_rows_request::Rows {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::append_rows_request::Rows, gaxi::prost::ConvertError> {
        use crate::write::generated::gapic_storage::model::append_rows_request::Rows as T;
        match self {
            Self::ProtoRows(v) => Ok(T::ProtoRows(std::boxed::Box::new(v.cnv()?))),
            Self::ArrowRows(v) => Ok(T::ArrowRows(std::boxed::Box::new(v.cnv()?))),
        }
    }
}

impl gaxi::prost::ToProto<AppendRowsRequest> for crate::write::generated::gapic_storage::model::AppendRowsRequest {
    type Output = AppendRowsRequest;
    fn to_proto(self) -> std::result::Result<AppendRowsRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            write_stream: self.write_stream.to_proto()?,
            offset: self.offset.map(|v| v.to_proto()).transpose()?,
            trace_id: self.trace_id.to_proto()?,
            missing_value_interpretations: self.missing_value_interpretations
                .into_iter()
                .map(|(k, v)| {
                    gaxi::prost::pair_transpose(k.to_proto(), v.to_proto())
                }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            default_missing_value_interpretation: self.default_missing_value_interpretation.to_proto()?,
            client_stats: self.client_stats.map(|v| v.to_proto()).transpose()?,
            rows: self.rows.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::AppendRowsRequest> for AppendRowsRequest {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::AppendRowsRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::AppendRowsRequest::new()
                .set_write_stream(self.write_stream)
                .set_or_clear_offset(self.offset.map(|v| v.cnv()).transpose()?)
                .set_trace_id(self.trace_id)
                .set_missing_value_interpretations(self.missing_value_interpretations.into_iter()
                    .map(|(k, v)| {
                        gaxi::prost::pair_transpose(k.cnv(), v.cnv())
                    }).collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?)
                .set_default_missing_value_interpretation(self.default_missing_value_interpretation)
                .set_or_clear_client_stats(self.client_stats.map(|v| v.cnv()).transpose()?)
                .set_rows(self.rows.map(|v| v.cnv()).transpose()?)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::append_rows_response::AppendResult> for append_rows_response::AppendResult {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::append_rows_response::AppendResult, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::append_rows_response::AppendResult::new()
                .set_or_clear_offset(self.offset.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<append_rows_response::Response> for crate::write::generated::gapic_storage::model::append_rows_response::Response {
    type Output = append_rows_response::Response;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::AppendResult(v) => Ok(Self::Output::AppendResult((*v).to_proto()?)),
            Self::Error(v) => Ok(Self::Output::Error((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::append_rows_response::Response> for append_rows_response::Response {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::append_rows_response::Response, gaxi::prost::ConvertError> {
        use crate::write::generated::gapic_storage::model::append_rows_response::Response as T;
        match self {
            Self::AppendResult(v) => Ok(T::AppendResult(std::boxed::Box::new(v.cnv()?))),
            Self::Error(v) => Ok(T::Error(std::boxed::Box::new(v.cnv()?))),
        }
    }
}

impl gaxi::prost::ToProto<AppendRowsResponse> for crate::write::generated::gapic_storage::model::AppendRowsResponse {
    type Output = AppendRowsResponse;
    fn to_proto(self) -> std::result::Result<AppendRowsResponse, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            updated_schema: self.updated_schema.map(|v| v.to_proto()).transpose()?,
            row_errors: self.row_errors
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            write_stream: self.write_stream.to_proto()?,
            response: self.response.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::AppendRowsResponse> for AppendRowsResponse {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::AppendRowsResponse, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::AppendRowsResponse::new()
                .set_or_clear_updated_schema(self.updated_schema.map(|v| v.cnv()).transpose()?)
                .set_row_errors(self.row_errors.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_write_stream(self.write_stream)
                .set_response(self.response.map(|v| v.cnv()).transpose()?)
        )
    }
}

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

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

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::BatchCommitWriteStreamsRequest> for BatchCommitWriteStreamsRequest {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::BatchCommitWriteStreamsRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::BatchCommitWriteStreamsRequest::new()
                .set_parent(self.parent)
                .set_write_streams(self.write_streams.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::BatchCommitWriteStreamsResponse> for BatchCommitWriteStreamsResponse {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::BatchCommitWriteStreamsResponse, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::BatchCommitWriteStreamsResponse::new()
                .set_or_clear_commit_time(self.commit_time.map(|v| v.cnv()).transpose()?)
                .set_stream_errors(self.stream_errors.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}

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

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

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::FinalizeWriteStreamResponse> for FinalizeWriteStreamResponse {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::FinalizeWriteStreamResponse, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::FinalizeWriteStreamResponse::new()
                .set_row_count(self.row_count)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::FlushRowsRequest> for FlushRowsRequest {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::FlushRowsRequest, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::FlushRowsRequest::new()
                .set_write_stream(self.write_stream)
                .set_or_clear_offset(self.offset.map(|v| v.cnv()).transpose()?)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::FlushRowsResponse> for FlushRowsResponse {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::FlushRowsResponse, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::FlushRowsResponse::new()
                .set_offset(self.offset)
        )
    }
}

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

impl gaxi::prost::ToProto<StorageError> for crate::write::generated::gapic_storage::model::StorageError {
    type Output = StorageError;
    fn to_proto(self) -> std::result::Result<StorageError, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            code: self.code.to_proto()?,
            entity: self.entity.to_proto()?,
            error_message: self.error_message.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::StorageError> for StorageError {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::StorageError, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::StorageError::new()
                .set_code(self.code)
                .set_entity(self.entity)
                .set_error_message(self.error_message)
        )
    }
}

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

impl gaxi::prost::ToProto<RowError> for crate::write::generated::gapic_storage::model::RowError {
    type Output = RowError;
    fn to_proto(self) -> std::result::Result<RowError, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            index: self.index.to_proto()?,
            code: self.code.to_proto()?,
            message: self.message.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::RowError> for RowError {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::RowError, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::RowError::new()
                .set_index(self.index)
                .set_code(self.code)
                .set_message(self.message)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::client_stats::RequestStats> for client_stats::RequestStats {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::client_stats::RequestStats, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::client_stats::RequestStats::new()
                .set_or_clear_send_time_millis(self.send_time_millis.map(|v| v.cnv()).transpose()?)
                .set_or_clear_queued_requests_count(self.queued_requests_count.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<client_stats::WindowStats> for crate::write::generated::gapic_storage::model::client_stats::WindowStats {
    type Output = client_stats::WindowStats;
    fn to_proto(self) -> std::result::Result<client_stats::WindowStats, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            max_response_latency_millis: self.max_response_latency_millis.map(|v| v.to_proto()).transpose()?,
            avg_response_latency_millis: self.avg_response_latency_millis.map(|v| v.to_proto()).transpose()?,
            longest_wait_no_response_millis: self.longest_wait_no_response_millis.map(|v| v.to_proto()).transpose()?,
            requests_sent_count: self.requests_sent_count.map(|v| v.to_proto()).transpose()?,
            responses_received_count: self.responses_received_count.map(|v| v.to_proto()).transpose()?,
            bytes_sent_count: self.bytes_sent_count.map(|v| v.to_proto()).transpose()?,
            window_start_time_epoch_millis: self.window_start_time_epoch_millis.map(|v| v.to_proto()).transpose()?,
            window_millis: self.window_millis.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::client_stats::WindowStats> for client_stats::WindowStats {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::client_stats::WindowStats, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::client_stats::WindowStats::new()
                .set_or_clear_max_response_latency_millis(self.max_response_latency_millis.map(|v| v.cnv()).transpose()?)
                .set_or_clear_avg_response_latency_millis(self.avg_response_latency_millis.map(|v| v.cnv()).transpose()?)
                .set_or_clear_longest_wait_no_response_millis(self.longest_wait_no_response_millis.map(|v| v.cnv()).transpose()?)
                .set_or_clear_requests_sent_count(self.requests_sent_count.map(|v| v.cnv()).transpose()?)
                .set_or_clear_responses_received_count(self.responses_received_count.map(|v| v.cnv()).transpose()?)
                .set_or_clear_bytes_sent_count(self.bytes_sent_count.map(|v| v.cnv()).transpose()?)
                .set_or_clear_window_start_time_epoch_millis(self.window_start_time_epoch_millis.map(|v| v.cnv()).transpose()?)
                .set_or_clear_window_millis(self.window_millis.map(|v| v.cnv()).transpose()?)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::ClientStats> for ClientStats {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::ClientStats, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::ClientStats::new()
                .set_or_clear_request_stats(self.request_stats.map(|v| v.cnv()).transpose()?)
                .set_or_clear_window_stats(self.window_stats.map(|v| v.cnv()).transpose()?)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::read_session::TableModifiers> for read_session::TableModifiers {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::read_session::TableModifiers, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::read_session::TableModifiers::new()
                .set_or_clear_snapshot_time(self.snapshot_time.map(|v| v.cnv()).transpose()?)
        )
    }
}

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

impl gaxi::prost::ToProto<read_session::table_read_options::OutputFormatSerializationOptions> for crate::write::generated::gapic_storage::model::read_session::table_read_options::OutputFormatSerializationOptions {
    type Output = read_session::table_read_options::OutputFormatSerializationOptions;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::ArrowSerializationOptions(v) => Ok(Self::Output::ArrowSerializationOptions((*v).to_proto()?)),
            Self::AvroSerializationOptions(v) => Ok(Self::Output::AvroSerializationOptions((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::read_session::table_read_options::OutputFormatSerializationOptions> for read_session::table_read_options::OutputFormatSerializationOptions {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::read_session::table_read_options::OutputFormatSerializationOptions, gaxi::prost::ConvertError> {
        use crate::write::generated::gapic_storage::model::read_session::table_read_options::OutputFormatSerializationOptions as T;
        match self {
            Self::ArrowSerializationOptions(v) => Ok(T::ArrowSerializationOptions(std::boxed::Box::new(v.cnv()?))),
            Self::AvroSerializationOptions(v) => Ok(T::AvroSerializationOptions(std::boxed::Box::new(v.cnv()?))),
        }
    }
}

impl gaxi::prost::ToProto<read_session::TableReadOptions> for crate::write::generated::gapic_storage::model::read_session::TableReadOptions {
    type Output = read_session::TableReadOptions;
    fn to_proto(self) -> std::result::Result<read_session::TableReadOptions, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            selected_fields: self.selected_fields
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            row_restriction: self.row_restriction.to_proto()?,
            sample_percentage: self.sample_percentage.map(|v| v.to_proto()).transpose()?,
            response_compression_codec: self.response_compression_codec.map(|v| v.to_proto()).transpose()?,
            output_format_serialization_options: self.output_format_serialization_options.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::read_session::TableReadOptions> for read_session::TableReadOptions {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::read_session::TableReadOptions, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::read_session::TableReadOptions::new()
                .set_selected_fields(self.selected_fields.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_row_restriction(self.row_restriction)
                .set_or_clear_sample_percentage(self.sample_percentage.map(|v| v.cnv()).transpose()?)
                .set_or_clear_response_compression_codec(self.response_compression_codec.map(|v| v.cnv()).transpose()?)
                .set_output_format_serialization_options(self.output_format_serialization_options.map(|v| v.cnv()).transpose()?)
        )
    }
}

impl gaxi::prost::ToProto<read_session::Schema> for crate::write::generated::gapic_storage::model::read_session::Schema {
    type Output = read_session::Schema;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::AvroSchema(v) => Ok(Self::Output::AvroSchema((*v).to_proto()?)),
            Self::ArrowSchema(v) => Ok(Self::Output::ArrowSchema((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::read_session::Schema> for read_session::Schema {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::read_session::Schema, gaxi::prost::ConvertError> {
        use crate::write::generated::gapic_storage::model::read_session::Schema as T;
        match self {
            Self::AvroSchema(v) => Ok(T::AvroSchema(std::boxed::Box::new(v.cnv()?))),
            Self::ArrowSchema(v) => Ok(T::ArrowSchema(std::boxed::Box::new(v.cnv()?))),
        }
    }
}

impl gaxi::prost::ToProto<ReadSession> for crate::write::generated::gapic_storage::model::ReadSession {
    type Output = ReadSession;
    fn to_proto(self) -> std::result::Result<ReadSession, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            name: self.name.to_proto()?,
            expire_time: self.expire_time.map(|v| v.to_proto()).transpose()?,
            data_format: self.data_format.to_proto()?,
            table: self.table.to_proto()?,
            table_modifiers: self.table_modifiers.map(|v| v.to_proto()).transpose()?,
            read_options: self.read_options.map(|v| v.to_proto()).transpose()?,
            streams: self.streams
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            estimated_total_bytes_scanned: self.estimated_total_bytes_scanned.to_proto()?,
            estimated_total_physical_file_size: self.estimated_total_physical_file_size.to_proto()?,
            estimated_row_count: self.estimated_row_count.to_proto()?,
            trace_id: self.trace_id.to_proto()?,
            schema: self.schema.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::ReadSession> for ReadSession {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::ReadSession, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::ReadSession::new()
                .set_name(self.name)
                .set_or_clear_expire_time(self.expire_time.map(|v| v.cnv()).transpose()?)
                .set_data_format(self.data_format)
                .set_table(self.table)
                .set_or_clear_table_modifiers(self.table_modifiers.map(|v| v.cnv()).transpose()?)
                .set_or_clear_read_options(self.read_options.map(|v| v.cnv()).transpose()?)
                .set_streams(self.streams.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_estimated_total_bytes_scanned(self.estimated_total_bytes_scanned)
                .set_estimated_total_physical_file_size(self.estimated_total_physical_file_size)
                .set_estimated_row_count(self.estimated_row_count)
                .set_trace_id(self.trace_id)
                .set_schema(self.schema.map(|v| v.cnv()).transpose()?)
        )
    }
}

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

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

impl gaxi::prost::ToProto<write_stream::Type> for crate::write::generated::gapic_storage::model::write_stream::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::write::generated::gapic_storage::model::write_stream::Type"))
    }
}

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

impl gaxi::prost::ToProto<WriteStream> for crate::write::generated::gapic_storage::model::WriteStream {
    type Output = WriteStream;
    fn to_proto(self) -> std::result::Result<WriteStream, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            name: self.name.to_proto()?,
            r#type: self.r#type.to_proto()?,
            create_time: self.create_time.map(|v| v.to_proto()).transpose()?,
            commit_time: self.commit_time.map(|v| v.to_proto()).transpose()?,
            table_schema: self.table_schema.map(|v| v.to_proto()).transpose()?,
            write_mode: self.write_mode.to_proto()?,
            location: self.location.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::WriteStream> for WriteStream {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::WriteStream, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::WriteStream::new()
                .set_name(self.name)
                .set_type(self.r#type)
                .set_or_clear_create_time(self.create_time.map(|v| v.cnv()).transpose()?)
                .set_or_clear_commit_time(self.commit_time.map(|v| v.cnv()).transpose()?)
                .set_or_clear_table_schema(self.table_schema.map(|v| v.cnv()).transpose()?)
                .set_write_mode(self.write_mode)
                .set_location(self.location)
        )
    }
}

impl gaxi::prost::ToProto<TableSchema> for crate::write::generated::gapic_storage::model::TableSchema {
    type Output = TableSchema;
    fn to_proto(self) -> std::result::Result<TableSchema, 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::write::generated::gapic_storage::model::TableSchema> for TableSchema {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::TableSchema, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::TableSchema::new()
                .set_fields(self.fields.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
        )
    }
}

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

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::table_field_schema::FieldElementType> for table_field_schema::FieldElementType {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::table_field_schema::FieldElementType, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::table_field_schema::FieldElementType::new()
                .set_type(self.r#type)
        )
    }
}

impl gaxi::prost::ToProto<table_field_schema::Type> for crate::write::generated::gapic_storage::model::table_field_schema::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::write::generated::gapic_storage::model::table_field_schema::Type"))
    }
}

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

impl gaxi::prost::ToProto<TableFieldSchema> for crate::write::generated::gapic_storage::model::TableFieldSchema {
    type Output = TableFieldSchema;
    fn to_proto(self) -> std::result::Result<TableFieldSchema, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            name: self.name.to_proto()?,
            r#type: self.r#type.to_proto()?,
            mode: self.mode.to_proto()?,
            fields: self.fields
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            description: self.description.to_proto()?,
            max_length: self.max_length.to_proto()?,
            precision: self.precision.to_proto()?,
            scale: self.scale.to_proto()?,
            default_value_expression: self.default_value_expression.to_proto()?,
            timestamp_precision: self.timestamp_precision.map(|v| v.to_proto()).transpose()?,
            range_element_type: self.range_element_type.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::write::generated::gapic_storage::model::TableFieldSchema> for TableFieldSchema {
    fn cnv(self) -> std::result::Result<crate::write::generated::gapic_storage::model::TableFieldSchema, gaxi::prost::ConvertError> {
        Ok(
            crate::write::generated::gapic_storage::model::TableFieldSchema::new()
                .set_name(self.name)
                .set_type(self.r#type)
                .set_mode(self.mode)
                .set_fields(self.fields.into_iter().map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?)
                .set_description(self.description)
                .set_max_length(self.max_length)
                .set_precision(self.precision)
                .set_scale(self.scale)
                .set_default_value_expression(self.default_value_expression)
                .set_or_clear_timestamp_precision(self.timestamp_precision.map(|v| v.cnv()).transpose()?)
                .set_or_clear_range_element_type(self.range_element_type.map(|v| v.cnv()).transpose()?)
        )
    }
}