google-cloud-spanner 0.34.1-preview

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

#![allow(rustdoc::redundant_explicit_links)]
#![allow(rustdoc::broken_intra_doc_links)]

mod debug;
mod deserialize;
mod serialize;

/// Spanner Change Streams enable customers to capture and stream out changes to
/// their Spanner databases in real-time. A change stream
/// can be created with option partition_mode='IMMUTABLE_KEY_RANGE' or
/// partition_mode='MUTABLE_KEY_RANGE'.
///
/// This message is only used in Change Streams created with the option
/// partition_mode='MUTABLE_KEY_RANGE'. Spanner automatically creates a special
/// Table-Valued Function (TVF) along with each Change Streams. The function
/// provides access to the change stream's records. The function is named
/// READ_<change_stream_name> (where <change_stream_name> is the
/// name of the change stream), and it returns a table with only one column
/// called ChangeRecord.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ChangeStreamRecord {
    /// One of the change stream subrecords.
    pub record: std::option::Option<crate::model::change_stream_record::Record>,

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

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

    /// Sets the value of [record][crate::model::ChangeStreamRecord::record].
    ///
    /// Note that all the setters affecting `record` are mutually
    /// exclusive.
    pub fn set_record<
        T: std::convert::Into<std::option::Option<crate::model::change_stream_record::Record>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.record = v.into();
        self
    }

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

    /// Sets the value of [record][crate::model::ChangeStreamRecord::record]
    /// to hold a `DataChangeRecord`.
    ///
    /// Note that all the setters affecting `record` are
    /// mutually exclusive.
    pub fn set_data_change_record<
        T: std::convert::Into<std::boxed::Box<crate::model::change_stream_record::DataChangeRecord>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.record = std::option::Option::Some(
            crate::model::change_stream_record::Record::DataChangeRecord(v.into()),
        );
        self
    }

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

    /// Sets the value of [record][crate::model::ChangeStreamRecord::record]
    /// to hold a `HeartbeatRecord`.
    ///
    /// Note that all the setters affecting `record` are
    /// mutually exclusive.
    pub fn set_heartbeat_record<
        T: std::convert::Into<std::boxed::Box<crate::model::change_stream_record::HeartbeatRecord>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.record = std::option::Option::Some(
            crate::model::change_stream_record::Record::HeartbeatRecord(v.into()),
        );
        self
    }

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

    /// Sets the value of [record][crate::model::ChangeStreamRecord::record]
    /// to hold a `PartitionStartRecord`.
    ///
    /// Note that all the setters affecting `record` are
    /// mutually exclusive.
    pub fn set_partition_start_record<
        T: std::convert::Into<
                std::boxed::Box<crate::model::change_stream_record::PartitionStartRecord>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.record = std::option::Option::Some(
            crate::model::change_stream_record::Record::PartitionStartRecord(v.into()),
        );
        self
    }

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

    /// Sets the value of [record][crate::model::ChangeStreamRecord::record]
    /// to hold a `PartitionEndRecord`.
    ///
    /// Note that all the setters affecting `record` are
    /// mutually exclusive.
    pub fn set_partition_end_record<
        T: std::convert::Into<std::boxed::Box<crate::model::change_stream_record::PartitionEndRecord>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.record = std::option::Option::Some(
            crate::model::change_stream_record::Record::PartitionEndRecord(v.into()),
        );
        self
    }

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

    /// Sets the value of [record][crate::model::ChangeStreamRecord::record]
    /// to hold a `PartitionEventRecord`.
    ///
    /// Note that all the setters affecting `record` are
    /// mutually exclusive.
    pub fn set_partition_event_record<
        T: std::convert::Into<
                std::boxed::Box<crate::model::change_stream_record::PartitionEventRecord>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.record = std::option::Option::Some(
            crate::model::change_stream_record::Record::PartitionEventRecord(v.into()),
        );
        self
    }
}

impl wkt::message::Message for ChangeStreamRecord {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.ChangeStreamRecord"
    }
}

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

    /// A data change record contains a set of changes to a table with the same
    /// modification type (insert, update, or delete) committed at the same commit
    /// timestamp in one change stream partition for the same transaction. Multiple
    /// data change records can be returned for the same transaction across
    /// multiple change stream partitions.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct DataChangeRecord {
        /// Indicates the timestamp in which the change was committed.
        /// DataChangeRecord.commit_timestamps,
        /// PartitionStartRecord.start_timestamps,
        /// PartitionEventRecord.commit_timestamps, and
        /// PartitionEndRecord.end_timestamps can have the same value in the same
        /// partition.
        pub commit_timestamp: std::option::Option<wkt::Timestamp>,

        /// Record sequence numbers are unique and monotonically increasing (but not
        /// necessarily contiguous) for a specific timestamp across record
        /// types in the same partition. To guarantee ordered processing, the reader
        /// should process records (of potentially different types) in
        /// record_sequence order for a specific timestamp in the same partition.
        ///
        /// The record sequence number ordering across partitions is only meaningful
        /// in the context of a specific transaction. Record sequence numbers are
        /// unique across partitions for a specific transaction. Sort the
        /// DataChangeRecords for the same
        /// [server_transaction_id][google.spanner.v1.ChangeStreamRecord.DataChangeRecord.server_transaction_id]
        /// by
        /// [record_sequence][google.spanner.v1.ChangeStreamRecord.DataChangeRecord.record_sequence]
        /// to reconstruct the ordering of the changes within the transaction.
        ///
        /// [google.spanner.v1.ChangeStreamRecord.DataChangeRecord.record_sequence]: crate::model::change_stream_record::DataChangeRecord::record_sequence
        /// [google.spanner.v1.ChangeStreamRecord.DataChangeRecord.server_transaction_id]: crate::model::change_stream_record::DataChangeRecord::server_transaction_id
        pub record_sequence: std::string::String,

        /// Provides a globally unique string that represents the transaction in
        /// which the change was committed. Multiple transactions can have the same
        /// commit timestamp, but each transaction has a unique
        /// server_transaction_id.
        pub server_transaction_id: std::string::String,

        /// Indicates whether this is the last record for a transaction in the
        /// current partition. Clients can use this field to determine when all
        /// records for a transaction in the current partition have been received.
        pub is_last_record_in_transaction_in_partition: bool,

        /// Name of the table affected by the change.
        pub table: std::string::String,

        /// Provides metadata describing the columns associated with the
        /// [mods][google.spanner.v1.ChangeStreamRecord.DataChangeRecord.mods] listed
        /// below.
        ///
        /// [google.spanner.v1.ChangeStreamRecord.DataChangeRecord.mods]: crate::model::change_stream_record::DataChangeRecord::mods
        pub column_metadata:
            std::vec::Vec<crate::model::change_stream_record::data_change_record::ColumnMetadata>,

        /// Describes the changes that were made.
        pub mods: std::vec::Vec<crate::model::change_stream_record::data_change_record::Mod>,

        /// Describes the type of change.
        pub mod_type: crate::model::change_stream_record::data_change_record::ModType,

        /// Describes the value capture type that was specified in the change stream
        /// configuration when this change was captured.
        pub value_capture_type:
            crate::model::change_stream_record::data_change_record::ValueCaptureType,

        /// Indicates the number of data change records that are part of this
        /// transaction across all change stream partitions. This value can be used
        /// to assemble all the records associated with a particular transaction.
        pub number_of_records_in_transaction: i32,

        /// Indicates the number of partitions that return data change records for
        /// this transaction. This value can be helpful in assembling all records
        /// associated with a particular transaction.
        pub number_of_partitions_in_transaction: i32,

        /// Indicates the transaction tag associated with this transaction.
        pub transaction_tag: std::string::String,

        /// Indicates whether the transaction is a system transaction. System
        /// transactions include those issued by time-to-live (TTL), column backfill,
        /// etc.
        pub is_system_transaction: bool,

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

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

        /// Sets the value of [commit_timestamp][crate::model::change_stream_record::DataChangeRecord::commit_timestamp].
        pub fn set_commit_timestamp<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.commit_timestamp = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [commit_timestamp][crate::model::change_stream_record::DataChangeRecord::commit_timestamp].
        pub fn set_or_clear_commit_timestamp<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.commit_timestamp = v.map(|x| x.into());
            self
        }

        /// Sets the value of [record_sequence][crate::model::change_stream_record::DataChangeRecord::record_sequence].
        pub fn set_record_sequence<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.record_sequence = v.into();
            self
        }

        /// Sets the value of [server_transaction_id][crate::model::change_stream_record::DataChangeRecord::server_transaction_id].
        pub fn set_server_transaction_id<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.server_transaction_id = v.into();
            self
        }

        /// Sets the value of [is_last_record_in_transaction_in_partition][crate::model::change_stream_record::DataChangeRecord::is_last_record_in_transaction_in_partition].
        pub fn set_is_last_record_in_transaction_in_partition<T: std::convert::Into<bool>>(
            mut self,
            v: T,
        ) -> Self {
            self.is_last_record_in_transaction_in_partition = v.into();
            self
        }

        /// Sets the value of [table][crate::model::change_stream_record::DataChangeRecord::table].
        pub fn set_table<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.table = v.into();
            self
        }

        /// Sets the value of [column_metadata][crate::model::change_stream_record::DataChangeRecord::column_metadata].
        pub fn set_column_metadata<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<
                    crate::model::change_stream_record::data_change_record::ColumnMetadata,
                >,
        {
            use std::iter::Iterator;
            self.column_metadata = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [mods][crate::model::change_stream_record::DataChangeRecord::mods].
        pub fn set_mods<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<crate::model::change_stream_record::data_change_record::Mod>,
        {
            use std::iter::Iterator;
            self.mods = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [mod_type][crate::model::change_stream_record::DataChangeRecord::mod_type].
        pub fn set_mod_type<
            T: std::convert::Into<crate::model::change_stream_record::data_change_record::ModType>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.mod_type = v.into();
            self
        }

        /// Sets the value of [value_capture_type][crate::model::change_stream_record::DataChangeRecord::value_capture_type].
        pub fn set_value_capture_type<
            T: std::convert::Into<
                    crate::model::change_stream_record::data_change_record::ValueCaptureType,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.value_capture_type = v.into();
            self
        }

        /// Sets the value of [number_of_records_in_transaction][crate::model::change_stream_record::DataChangeRecord::number_of_records_in_transaction].
        pub fn set_number_of_records_in_transaction<T: std::convert::Into<i32>>(
            mut self,
            v: T,
        ) -> Self {
            self.number_of_records_in_transaction = v.into();
            self
        }

        /// Sets the value of [number_of_partitions_in_transaction][crate::model::change_stream_record::DataChangeRecord::number_of_partitions_in_transaction].
        pub fn set_number_of_partitions_in_transaction<T: std::convert::Into<i32>>(
            mut self,
            v: T,
        ) -> Self {
            self.number_of_partitions_in_transaction = v.into();
            self
        }

        /// Sets the value of [transaction_tag][crate::model::change_stream_record::DataChangeRecord::transaction_tag].
        pub fn set_transaction_tag<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.transaction_tag = v.into();
            self
        }

        /// Sets the value of [is_system_transaction][crate::model::change_stream_record::DataChangeRecord::is_system_transaction].
        pub fn set_is_system_transaction<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.is_system_transaction = v.into();
            self
        }
    }

    impl wkt::message::Message for DataChangeRecord {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.ChangeStreamRecord.DataChangeRecord"
        }
    }

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

        /// Metadata for a column.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct ColumnMetadata {
            /// Name of the column.
            pub name: std::string::String,

            /// Type of the column.
            pub r#type: std::option::Option<crate::model::Type>,

            /// Indicates whether the column is a primary key column.
            pub is_primary_key: bool,

            /// Ordinal position of the column based on the original table definition
            /// in the schema starting with a value of 1.
            pub ordinal_position: i64,

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

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

            /// Sets the value of [name][crate::model::change_stream_record::data_change_record::ColumnMetadata::name].
            pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
                self.name = v.into();
                self
            }

            /// Sets the value of [r#type][crate::model::change_stream_record::data_change_record::ColumnMetadata::type].
            pub fn set_type<T>(mut self, v: T) -> Self
            where
                T: std::convert::Into<crate::model::Type>,
            {
                self.r#type = std::option::Option::Some(v.into());
                self
            }

            /// Sets or clears the value of [r#type][crate::model::change_stream_record::data_change_record::ColumnMetadata::type].
            pub fn set_or_clear_type<T>(mut self, v: std::option::Option<T>) -> Self
            where
                T: std::convert::Into<crate::model::Type>,
            {
                self.r#type = v.map(|x| x.into());
                self
            }

            /// Sets the value of [is_primary_key][crate::model::change_stream_record::data_change_record::ColumnMetadata::is_primary_key].
            pub fn set_is_primary_key<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
                self.is_primary_key = v.into();
                self
            }

            /// Sets the value of [ordinal_position][crate::model::change_stream_record::data_change_record::ColumnMetadata::ordinal_position].
            pub fn set_ordinal_position<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
                self.ordinal_position = v.into();
                self
            }
        }

        impl wkt::message::Message for ColumnMetadata {
            fn typename() -> &'static str {
                "type.googleapis.com/google.spanner.v1.ChangeStreamRecord.DataChangeRecord.ColumnMetadata"
            }
        }

        /// Returns the value and associated metadata for a particular field of the
        /// [Mod][google.spanner.v1.ChangeStreamRecord.DataChangeRecord.Mod].
        ///
        /// [google.spanner.v1.ChangeStreamRecord.DataChangeRecord.Mod]: crate::model::change_stream_record::data_change_record::Mod
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct ModValue {
            /// Index within the repeated
            /// [column_metadata][google.spanner.v1.ChangeStreamRecord.DataChangeRecord.column_metadata]
            /// field, to obtain the column metadata for the column that was modified.
            ///
            /// [google.spanner.v1.ChangeStreamRecord.DataChangeRecord.column_metadata]: crate::model::change_stream_record::DataChangeRecord::column_metadata
            pub column_metadata_index: i32,

            /// The value of the column.
            pub value: std::option::Option<wkt::Value>,

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

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

            /// Sets the value of [column_metadata_index][crate::model::change_stream_record::data_change_record::ModValue::column_metadata_index].
            pub fn set_column_metadata_index<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
                self.column_metadata_index = v.into();
                self
            }

            /// Sets the value of [value][crate::model::change_stream_record::data_change_record::ModValue::value].
            pub fn set_value<T>(mut self, v: T) -> Self
            where
                T: std::convert::Into<wkt::Value>,
            {
                self.value = std::option::Option::Some(v.into());
                self
            }

            /// Sets or clears the value of [value][crate::model::change_stream_record::data_change_record::ModValue::value].
            pub fn set_or_clear_value<T>(mut self, v: std::option::Option<T>) -> Self
            where
                T: std::convert::Into<wkt::Value>,
            {
                self.value = v.map(|x| x.into());
                self
            }
        }

        impl wkt::message::Message for ModValue {
            fn typename() -> &'static str {
                "type.googleapis.com/google.spanner.v1.ChangeStreamRecord.DataChangeRecord.ModValue"
            }
        }

        /// A mod describes all data changes in a watched table row.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct Mod {
            /// Returns the value of the primary key of the modified row.
            pub keys:
                std::vec::Vec<crate::model::change_stream_record::data_change_record::ModValue>,

            /// Returns the old values before the change for the modified columns.
            /// Always empty for
            /// [INSERT][google.spanner.v1.ChangeStreamRecord.DataChangeRecord.ModType.INSERT],
            /// or if old values are not being captured specified by
            /// [value_capture_type][google.spanner.v1.ChangeStreamRecord.DataChangeRecord.ValueCaptureType].
            ///
            /// [google.spanner.v1.ChangeStreamRecord.DataChangeRecord.ModType.INSERT]: crate::model::change_stream_record::data_change_record::ModType::Insert
            /// [google.spanner.v1.ChangeStreamRecord.DataChangeRecord.ValueCaptureType]: crate::model::change_stream_record::data_change_record::ValueCaptureType
            pub old_values:
                std::vec::Vec<crate::model::change_stream_record::data_change_record::ModValue>,

            /// Returns the new values after the change for the modified columns.
            /// Always empty for
            /// [DELETE][google.spanner.v1.ChangeStreamRecord.DataChangeRecord.ModType.DELETE].
            ///
            /// [google.spanner.v1.ChangeStreamRecord.DataChangeRecord.ModType.DELETE]: crate::model::change_stream_record::data_change_record::ModType::Delete
            pub new_values:
                std::vec::Vec<crate::model::change_stream_record::data_change_record::ModValue>,

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

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

            /// Sets the value of [keys][crate::model::change_stream_record::data_change_record::Mod::keys].
            pub fn set_keys<T, V>(mut self, v: T) -> Self
            where
                T: std::iter::IntoIterator<Item = V>,
                V: std::convert::Into<
                        crate::model::change_stream_record::data_change_record::ModValue,
                    >,
            {
                use std::iter::Iterator;
                self.keys = v.into_iter().map(|i| i.into()).collect();
                self
            }

            /// Sets the value of [old_values][crate::model::change_stream_record::data_change_record::Mod::old_values].
            pub fn set_old_values<T, V>(mut self, v: T) -> Self
            where
                T: std::iter::IntoIterator<Item = V>,
                V: std::convert::Into<
                        crate::model::change_stream_record::data_change_record::ModValue,
                    >,
            {
                use std::iter::Iterator;
                self.old_values = v.into_iter().map(|i| i.into()).collect();
                self
            }

            /// Sets the value of [new_values][crate::model::change_stream_record::data_change_record::Mod::new_values].
            pub fn set_new_values<T, V>(mut self, v: T) -> Self
            where
                T: std::iter::IntoIterator<Item = V>,
                V: std::convert::Into<
                        crate::model::change_stream_record::data_change_record::ModValue,
                    >,
            {
                use std::iter::Iterator;
                self.new_values = v.into_iter().map(|i| i.into()).collect();
                self
            }
        }

        impl wkt::message::Message for Mod {
            fn typename() -> &'static str {
                "type.googleapis.com/google.spanner.v1.ChangeStreamRecord.DataChangeRecord.Mod"
            }
        }

        /// Mod type describes the type of change Spanner applied to the data. For
        /// example, if the client submits an INSERT_OR_UPDATE request, Spanner will
        /// perform an insert if there is no existing row and return ModType INSERT.
        /// Alternatively, if there is an existing row, Spanner will perform an
        /// update and return ModType UPDATE.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum ModType {
            /// Not specified.
            Unspecified,
            /// Indicates data was inserted.
            Insert,
            /// Indicates existing data was updated.
            Update,
            /// Indicates existing data was deleted.
            Delete,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [ModType::value] or
            /// [ModType::name].
            UnknownValue(mod_type::UnknownValue),
        }

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

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

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

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

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

        impl std::convert::From<i32> for ModType {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    10 => Self::Insert,
                    20 => Self::Update,
                    30 => Self::Delete,
                    _ => Self::UnknownValue(mod_type::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for ModType {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "MOD_TYPE_UNSPECIFIED" => Self::Unspecified,
                    "INSERT" => Self::Insert,
                    "UPDATE" => Self::Update,
                    "DELETE" => Self::Delete,
                    _ => Self::UnknownValue(mod_type::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for ModType {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::Insert => serializer.serialize_i32(10),
                    Self::Update => serializer.serialize_i32(20),
                    Self::Delete => serializer.serialize_i32(30),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for ModType {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<ModType>::new(
                    ".google.spanner.v1.ChangeStreamRecord.DataChangeRecord.ModType",
                ))
            }
        }

        /// Value capture type describes which values are recorded in the data
        /// change record.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum ValueCaptureType {
            /// Not specified.
            Unspecified,
            /// Records both old and new values of the modified watched columns.
            OldAndNewValues,
            /// Records only new values of the modified watched columns.
            NewValues,
            /// Records new values of all watched columns, including modified and
            /// unmodified columns.
            NewRow,
            /// Records the new values of all watched columns, including modified and
            /// unmodified columns. Also records the old values of the modified
            /// columns.
            NewRowAndOldValues,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [ValueCaptureType::value] or
            /// [ValueCaptureType::name].
            UnknownValue(value_capture_type::UnknownValue),
        }

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

        impl ValueCaptureType {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::Unspecified => std::option::Option::Some(0),
                    Self::OldAndNewValues => std::option::Option::Some(10),
                    Self::NewValues => std::option::Option::Some(20),
                    Self::NewRow => std::option::Option::Some(30),
                    Self::NewRowAndOldValues => std::option::Option::Some(40),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

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

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

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

        impl std::convert::From<i32> for ValueCaptureType {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    10 => Self::OldAndNewValues,
                    20 => Self::NewValues,
                    30 => Self::NewRow,
                    40 => Self::NewRowAndOldValues,
                    _ => Self::UnknownValue(value_capture_type::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for ValueCaptureType {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "VALUE_CAPTURE_TYPE_UNSPECIFIED" => Self::Unspecified,
                    "OLD_AND_NEW_VALUES" => Self::OldAndNewValues,
                    "NEW_VALUES" => Self::NewValues,
                    "NEW_ROW" => Self::NewRow,
                    "NEW_ROW_AND_OLD_VALUES" => Self::NewRowAndOldValues,
                    _ => Self::UnknownValue(value_capture_type::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for ValueCaptureType {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::OldAndNewValues => serializer.serialize_i32(10),
                    Self::NewValues => serializer.serialize_i32(20),
                    Self::NewRow => serializer.serialize_i32(30),
                    Self::NewRowAndOldValues => serializer.serialize_i32(40),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for ValueCaptureType {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<ValueCaptureType>::new(
                    ".google.spanner.v1.ChangeStreamRecord.DataChangeRecord.ValueCaptureType",
                ))
            }
        }
    }

    /// A heartbeat record is returned as a progress indicator, when there are no
    /// data changes or any other partition record types in the change stream
    /// partition.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct HeartbeatRecord {
        /// Indicates the timestamp at which the query has returned all the records
        /// in the change stream partition with timestamp <= heartbeat timestamp.
        /// The heartbeat timestamp will not be the same as the timestamps of other
        /// record types in the same partition.
        pub timestamp: std::option::Option<wkt::Timestamp>,

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

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

        /// Sets the value of [timestamp][crate::model::change_stream_record::HeartbeatRecord::timestamp].
        pub fn set_timestamp<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.timestamp = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [timestamp][crate::model::change_stream_record::HeartbeatRecord::timestamp].
        pub fn set_or_clear_timestamp<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.timestamp = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for HeartbeatRecord {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.ChangeStreamRecord.HeartbeatRecord"
        }
    }

    /// A partition start record serves as a notification that the client should
    /// schedule the partitions to be queried. PartitionStartRecord returns
    /// information about one or more partitions.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct PartitionStartRecord {
        /// Start timestamp at which the partitions should be queried to return
        /// change stream records with timestamps >= start_timestamp.
        /// DataChangeRecord.commit_timestamps,
        /// PartitionStartRecord.start_timestamps,
        /// PartitionEventRecord.commit_timestamps, and
        /// PartitionEndRecord.end_timestamps can have the same value in the same
        /// partition.
        pub start_timestamp: std::option::Option<wkt::Timestamp>,

        /// Record sequence numbers are unique and monotonically increasing (but not
        /// necessarily contiguous) for a specific timestamp across record
        /// types in the same partition. To guarantee ordered processing, the reader
        /// should process records (of potentially different types) in
        /// record_sequence order for a specific timestamp in the same partition.
        pub record_sequence: std::string::String,

        /// Unique partition identifiers to be used in queries.
        pub partition_tokens: std::vec::Vec<std::string::String>,

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

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

        /// Sets the value of [start_timestamp][crate::model::change_stream_record::PartitionStartRecord::start_timestamp].
        pub fn set_start_timestamp<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.start_timestamp = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [start_timestamp][crate::model::change_stream_record::PartitionStartRecord::start_timestamp].
        pub fn set_or_clear_start_timestamp<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.start_timestamp = v.map(|x| x.into());
            self
        }

        /// Sets the value of [record_sequence][crate::model::change_stream_record::PartitionStartRecord::record_sequence].
        pub fn set_record_sequence<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.record_sequence = v.into();
            self
        }

        /// Sets the value of [partition_tokens][crate::model::change_stream_record::PartitionStartRecord::partition_tokens].
        pub fn set_partition_tokens<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<std::string::String>,
        {
            use std::iter::Iterator;
            self.partition_tokens = v.into_iter().map(|i| i.into()).collect();
            self
        }
    }

    impl wkt::message::Message for PartitionStartRecord {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.ChangeStreamRecord.PartitionStartRecord"
        }
    }

    /// A partition end record serves as a notification that the client should stop
    /// reading the partition. No further records are expected to be retrieved on
    /// it.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct PartitionEndRecord {
        /// End timestamp at which the change stream partition is terminated. All
        /// changes generated by this partition will have timestamps <=
        /// end_timestamp. DataChangeRecord.commit_timestamps,
        /// PartitionStartRecord.start_timestamps,
        /// PartitionEventRecord.commit_timestamps, and
        /// PartitionEndRecord.end_timestamps can have the same value in the same
        /// partition. PartitionEndRecord is the last record returned for a
        /// partition.
        pub end_timestamp: std::option::Option<wkt::Timestamp>,

        /// Record sequence numbers are unique and monotonically increasing (but not
        /// necessarily contiguous) for a specific timestamp across record
        /// types in the same partition. To guarantee ordered processing, the reader
        /// should process records (of potentially different types) in
        /// record_sequence order for a specific timestamp in the same partition.
        pub record_sequence: std::string::String,

        /// Unique partition identifier describing the terminated change stream
        /// partition.
        /// [partition_token][google.spanner.v1.ChangeStreamRecord.PartitionEndRecord.partition_token]
        /// is equal to the partition token of the change stream partition currently
        /// queried to return this PartitionEndRecord.
        ///
        /// [google.spanner.v1.ChangeStreamRecord.PartitionEndRecord.partition_token]: crate::model::change_stream_record::PartitionEndRecord::partition_token
        pub partition_token: std::string::String,

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

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

        /// Sets the value of [end_timestamp][crate::model::change_stream_record::PartitionEndRecord::end_timestamp].
        pub fn set_end_timestamp<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.end_timestamp = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [end_timestamp][crate::model::change_stream_record::PartitionEndRecord::end_timestamp].
        pub fn set_or_clear_end_timestamp<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.end_timestamp = v.map(|x| x.into());
            self
        }

        /// Sets the value of [record_sequence][crate::model::change_stream_record::PartitionEndRecord::record_sequence].
        pub fn set_record_sequence<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.record_sequence = v.into();
            self
        }

        /// Sets the value of [partition_token][crate::model::change_stream_record::PartitionEndRecord::partition_token].
        pub fn set_partition_token<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.partition_token = v.into();
            self
        }
    }

    impl wkt::message::Message for PartitionEndRecord {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.ChangeStreamRecord.PartitionEndRecord"
        }
    }

    /// A partition event record describes key range changes for a change stream
    /// partition. The changes to a row defined by its primary key can be captured
    /// in one change stream partition for a specific time range, and then be
    /// captured in a different change stream partition for a different time range.
    /// This movement of key ranges across change stream partitions is a reflection
    /// of activities, such as Spanner's dynamic splitting and load balancing, etc.
    /// Processing this event is needed if users want to guarantee processing of
    /// the changes for any key in timestamp order. If time ordered processing of
    /// changes for a primary key is not needed, this event can be ignored.
    /// To guarantee time ordered processing for each primary key, if the event
    /// describes move-ins, the reader of this partition needs to wait until the
    /// readers of the source partitions have processed all records with timestamps
    /// <= this PartitionEventRecord.commit_timestamp, before advancing beyond this
    /// PartitionEventRecord. If the event describes move-outs, the reader can
    /// notify the readers of the destination partitions that they can continue
    /// processing.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct PartitionEventRecord {
        /// Indicates the commit timestamp at which the key range change occurred.
        /// DataChangeRecord.commit_timestamps,
        /// PartitionStartRecord.start_timestamps,
        /// PartitionEventRecord.commit_timestamps, and
        /// PartitionEndRecord.end_timestamps can have the same value in the same
        /// partition.
        pub commit_timestamp: std::option::Option<wkt::Timestamp>,

        /// Record sequence numbers are unique and monotonically increasing (but not
        /// necessarily contiguous) for a specific timestamp across record
        /// types in the same partition. To guarantee ordered processing, the reader
        /// should process records (of potentially different types) in
        /// record_sequence order for a specific timestamp in the same partition.
        pub record_sequence: std::string::String,

        /// Unique partition identifier describing the partition this event
        /// occurred on.
        /// [partition_token][google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.partition_token]
        /// is equal to the partition token of the change stream partition currently
        /// queried to return this PartitionEventRecord.
        ///
        /// [google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.partition_token]: crate::model::change_stream_record::PartitionEventRecord::partition_token
        pub partition_token: std::string::String,

        /// Set when one or more key ranges are moved into the change stream
        /// partition identified by
        /// [partition_token][google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.partition_token].
        ///
        /// Example: Two key ranges are moved into partition (P1) from partition (P2)
        /// and partition (P3) in a single transaction at timestamp T.
        ///
        /// The PartitionEventRecord returned in P1 will reflect the move as:
        ///
        /// PartitionEventRecord {
        /// commit_timestamp: T
        /// partition_token: "P1"
        /// move_in_events {
        /// source_partition_token: "P2"
        /// }
        /// move_in_events {
        /// source_partition_token: "P3"
        /// }
        /// }
        ///
        /// The PartitionEventRecord returned in P2 will reflect the move as:
        ///
        /// PartitionEventRecord {
        /// commit_timestamp: T
        /// partition_token: "P2"
        /// move_out_events {
        /// destination_partition_token: "P1"
        /// }
        /// }
        ///
        /// The PartitionEventRecord returned in P3 will reflect the move as:
        ///
        /// PartitionEventRecord {
        /// commit_timestamp: T
        /// partition_token: "P3"
        /// move_out_events {
        /// destination_partition_token: "P1"
        /// }
        /// }
        ///
        /// [google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.partition_token]: crate::model::change_stream_record::PartitionEventRecord::partition_token
        pub move_in_events:
            std::vec::Vec<crate::model::change_stream_record::partition_event_record::MoveInEvent>,

        /// Set when one or more key ranges are moved out of the change stream
        /// partition identified by
        /// [partition_token][google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.partition_token].
        ///
        /// Example: Two key ranges are moved out of partition (P1) to partition (P2)
        /// and partition (P3) in a single transaction at timestamp T.
        ///
        /// The PartitionEventRecord returned in P1 will reflect the move as:
        ///
        /// PartitionEventRecord {
        /// commit_timestamp: T
        /// partition_token: "P1"
        /// move_out_events {
        /// destination_partition_token: "P2"
        /// }
        /// move_out_events {
        /// destination_partition_token: "P3"
        /// }
        /// }
        ///
        /// The PartitionEventRecord returned in P2 will reflect the move as:
        ///
        /// PartitionEventRecord {
        /// commit_timestamp: T
        /// partition_token: "P2"
        /// move_in_events {
        /// source_partition_token: "P1"
        /// }
        /// }
        ///
        /// The PartitionEventRecord returned in P3 will reflect the move as:
        ///
        /// PartitionEventRecord {
        /// commit_timestamp: T
        /// partition_token: "P3"
        /// move_in_events {
        /// source_partition_token: "P1"
        /// }
        /// }
        ///
        /// [google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.partition_token]: crate::model::change_stream_record::PartitionEventRecord::partition_token
        pub move_out_events:
            std::vec::Vec<crate::model::change_stream_record::partition_event_record::MoveOutEvent>,

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

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

        /// Sets the value of [commit_timestamp][crate::model::change_stream_record::PartitionEventRecord::commit_timestamp].
        pub fn set_commit_timestamp<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.commit_timestamp = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [commit_timestamp][crate::model::change_stream_record::PartitionEventRecord::commit_timestamp].
        pub fn set_or_clear_commit_timestamp<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.commit_timestamp = v.map(|x| x.into());
            self
        }

        /// Sets the value of [record_sequence][crate::model::change_stream_record::PartitionEventRecord::record_sequence].
        pub fn set_record_sequence<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.record_sequence = v.into();
            self
        }

        /// Sets the value of [partition_token][crate::model::change_stream_record::PartitionEventRecord::partition_token].
        pub fn set_partition_token<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.partition_token = v.into();
            self
        }

        /// Sets the value of [move_in_events][crate::model::change_stream_record::PartitionEventRecord::move_in_events].
        pub fn set_move_in_events<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<
                    crate::model::change_stream_record::partition_event_record::MoveInEvent,
                >,
        {
            use std::iter::Iterator;
            self.move_in_events = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [move_out_events][crate::model::change_stream_record::PartitionEventRecord::move_out_events].
        pub fn set_move_out_events<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<
                    crate::model::change_stream_record::partition_event_record::MoveOutEvent,
                >,
        {
            use std::iter::Iterator;
            self.move_out_events = v.into_iter().map(|i| i.into()).collect();
            self
        }
    }

    impl wkt::message::Message for PartitionEventRecord {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.ChangeStreamRecord.PartitionEventRecord"
        }
    }

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

        /// Describes move-in of the key ranges into the change stream partition
        /// identified by
        /// [partition_token][google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.partition_token].
        ///
        /// To maintain processing the changes for a particular key in timestamp
        /// order, the query processing the change stream partition identified by
        /// [partition_token][google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.partition_token]
        /// should not advance beyond the partition event record commit timestamp
        /// until the queries processing the source change stream partitions have
        /// processed all change stream records with timestamps <= the partition
        /// event record commit timestamp.
        ///
        /// [google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.partition_token]: crate::model::change_stream_record::PartitionEventRecord::partition_token
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct MoveInEvent {
            /// An unique partition identifier describing the source change stream
            /// partition that recorded changes for the key range that is moving
            /// into this partition.
            pub source_partition_token: std::string::String,

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

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

            /// Sets the value of [source_partition_token][crate::model::change_stream_record::partition_event_record::MoveInEvent::source_partition_token].
            pub fn set_source_partition_token<T: std::convert::Into<std::string::String>>(
                mut self,
                v: T,
            ) -> Self {
                self.source_partition_token = v.into();
                self
            }
        }

        impl wkt::message::Message for MoveInEvent {
            fn typename() -> &'static str {
                "type.googleapis.com/google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.MoveInEvent"
            }
        }

        /// Describes move-out of the key ranges out of the change stream partition
        /// identified by
        /// [partition_token][google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.partition_token].
        ///
        /// To maintain processing the changes for a particular key in timestamp
        /// order, the query processing the
        /// [MoveOutEvent][google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.MoveOutEvent]
        /// in the partition identified by
        /// [partition_token][google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.partition_token]
        /// should inform the queries processing the destination partitions that
        /// they can unblock and proceed processing records past the
        /// [commit_timestamp][google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.commit_timestamp].
        ///
        /// [google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.MoveOutEvent]: crate::model::change_stream_record::partition_event_record::MoveOutEvent
        /// [google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.commit_timestamp]: crate::model::change_stream_record::PartitionEventRecord::commit_timestamp
        /// [google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.partition_token]: crate::model::change_stream_record::PartitionEventRecord::partition_token
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct MoveOutEvent {
            /// An unique partition identifier describing the destination change
            /// stream partition that will record changes for the key range that is
            /// moving out of this partition.
            pub destination_partition_token: std::string::String,

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

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

            /// Sets the value of [destination_partition_token][crate::model::change_stream_record::partition_event_record::MoveOutEvent::destination_partition_token].
            pub fn set_destination_partition_token<T: std::convert::Into<std::string::String>>(
                mut self,
                v: T,
            ) -> Self {
                self.destination_partition_token = v.into();
                self
            }
        }

        impl wkt::message::Message for MoveOutEvent {
            fn typename() -> &'static str {
                "type.googleapis.com/google.spanner.v1.ChangeStreamRecord.PartitionEventRecord.MoveOutEvent"
            }
        }
    }

    /// One of the change stream subrecords.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Record {
        /// Data change record describing a data change for a change stream
        /// partition.
        DataChangeRecord(std::boxed::Box<crate::model::change_stream_record::DataChangeRecord>),
        /// Heartbeat record describing a heartbeat for a change stream partition.
        HeartbeatRecord(std::boxed::Box<crate::model::change_stream_record::HeartbeatRecord>),
        /// Partition start record describing a new change stream partition.
        PartitionStartRecord(
            std::boxed::Box<crate::model::change_stream_record::PartitionStartRecord>,
        ),
        /// Partition end record describing a terminated change stream partition.
        PartitionEndRecord(std::boxed::Box<crate::model::change_stream_record::PartitionEndRecord>),
        /// Partition event record describing key range changes for a change stream
        /// partition.
        PartitionEventRecord(
            std::boxed::Box<crate::model::change_stream_record::PartitionEventRecord>,
        ),
    }

    impl Record {
        /// Initializes the enum to the [DataChangeRecord](Self::DataChangeRecord) branch.
        pub fn from_data_change_record(
            value: impl std::convert::Into<
                std::boxed::Box<crate::model::change_stream_record::DataChangeRecord>,
            >,
        ) -> Self {
            Self::DataChangeRecord(value.into())
        }
        /// Initializes the enum to the [HeartbeatRecord](Self::HeartbeatRecord) branch.
        pub fn from_heartbeat_record(
            value: impl std::convert::Into<
                std::boxed::Box<crate::model::change_stream_record::HeartbeatRecord>,
            >,
        ) -> Self {
            Self::HeartbeatRecord(value.into())
        }
        /// Initializes the enum to the [PartitionStartRecord](Self::PartitionStartRecord) branch.
        pub fn from_partition_start_record(
            value: impl std::convert::Into<
                std::boxed::Box<crate::model::change_stream_record::PartitionStartRecord>,
            >,
        ) -> Self {
            Self::PartitionStartRecord(value.into())
        }
        /// Initializes the enum to the [PartitionEndRecord](Self::PartitionEndRecord) branch.
        pub fn from_partition_end_record(
            value: impl std::convert::Into<
                std::boxed::Box<crate::model::change_stream_record::PartitionEndRecord>,
            >,
        ) -> Self {
            Self::PartitionEndRecord(value.into())
        }
        /// Initializes the enum to the [PartitionEventRecord](Self::PartitionEventRecord) branch.
        pub fn from_partition_event_record(
            value: impl std::convert::Into<
                std::boxed::Box<crate::model::change_stream_record::PartitionEventRecord>,
            >,
        ) -> Self {
            Self::PartitionEventRecord(value.into())
        }
    }
}

/// The response for [Commit][google.spanner.v1.Spanner.Commit].
///
/// [google.spanner.v1.Spanner.Commit]: crate::client::Spanner::commit
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CommitResponse {
    /// The Cloud Spanner timestamp at which the transaction committed.
    pub commit_timestamp: std::option::Option<wkt::Timestamp>,

    /// The statistics about this `Commit`. Not returned by default.
    /// For more information, see
    /// [CommitRequest.return_commit_stats][google.spanner.v1.CommitRequest.return_commit_stats].
    ///
    /// [google.spanner.v1.CommitRequest.return_commit_stats]: crate::model::CommitRequest::return_commit_stats
    pub commit_stats: std::option::Option<crate::model::commit_response::CommitStats>,

    /// If `TransactionOptions.isolation_level` is set to
    /// `IsolationLevel.REPEATABLE_READ`, then the snapshot timestamp is the
    /// timestamp at which all reads in the transaction ran. This timestamp is
    /// never returned.
    pub snapshot_timestamp: std::option::Option<wkt::Timestamp>,

    /// Optional. A cache update expresses a set of changes the client should
    /// incorporate into its location cache. The client should discard the changes
    /// if they are older than the data it already has. This data can be obtained
    /// in response to requests that included a `RoutingHint` field, but may also
    /// be obtained by explicit location-fetching RPCs which may be added in the
    /// future.
    pub cache_update: std::option::Option<crate::model::CacheUpdate>,

    /// The isolation level used for the read-write transaction.
    pub isolation_level: crate::model::transaction_options::IsolationLevel,

    /// The read lock mode used for the read-write transaction.
    pub read_lock_mode: crate::model::transaction_options::read_write::ReadLockMode,

    /// You must examine and retry the commit if the following is populated.
    pub multiplexed_session_retry:
        std::option::Option<crate::model::commit_response::MultiplexedSessionRetry>,

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

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

    /// Sets the value of [commit_timestamp][crate::model::CommitResponse::commit_timestamp].
    pub fn set_commit_timestamp<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.commit_timestamp = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [commit_timestamp][crate::model::CommitResponse::commit_timestamp].
    pub fn set_or_clear_commit_timestamp<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.commit_timestamp = v.map(|x| x.into());
        self
    }

    /// Sets the value of [commit_stats][crate::model::CommitResponse::commit_stats].
    pub fn set_commit_stats<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::commit_response::CommitStats>,
    {
        self.commit_stats = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [commit_stats][crate::model::CommitResponse::commit_stats].
    pub fn set_or_clear_commit_stats<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::commit_response::CommitStats>,
    {
        self.commit_stats = v.map(|x| x.into());
        self
    }

    /// Sets the value of [snapshot_timestamp][crate::model::CommitResponse::snapshot_timestamp].
    pub fn set_snapshot_timestamp<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.snapshot_timestamp = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [snapshot_timestamp][crate::model::CommitResponse::snapshot_timestamp].
    pub fn set_or_clear_snapshot_timestamp<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.snapshot_timestamp = v.map(|x| x.into());
        self
    }

    /// Sets the value of [cache_update][crate::model::CommitResponse::cache_update].
    pub fn set_cache_update<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::CacheUpdate>,
    {
        self.cache_update = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [cache_update][crate::model::CommitResponse::cache_update].
    pub fn set_or_clear_cache_update<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::CacheUpdate>,
    {
        self.cache_update = v.map(|x| x.into());
        self
    }

    /// Sets the value of [isolation_level][crate::model::CommitResponse::isolation_level].
    pub fn set_isolation_level<
        T: std::convert::Into<crate::model::transaction_options::IsolationLevel>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.isolation_level = v.into();
        self
    }

    /// Sets the value of [read_lock_mode][crate::model::CommitResponse::read_lock_mode].
    pub fn set_read_lock_mode<
        T: std::convert::Into<crate::model::transaction_options::read_write::ReadLockMode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.read_lock_mode = v.into();
        self
    }

    /// Sets the value of [multiplexed_session_retry][crate::model::CommitResponse::multiplexed_session_retry].
    ///
    /// Note that all the setters affecting `multiplexed_session_retry` are mutually
    /// exclusive.
    pub fn set_multiplexed_session_retry<
        T: std::convert::Into<
                std::option::Option<crate::model::commit_response::MultiplexedSessionRetry>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.multiplexed_session_retry = v.into();
        self
    }

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

    /// Sets the value of [multiplexed_session_retry][crate::model::CommitResponse::multiplexed_session_retry]
    /// to hold a `PrecommitToken`.
    ///
    /// Note that all the setters affecting `multiplexed_session_retry` are
    /// mutually exclusive.
    pub fn set_precommit_token<
        T: std::convert::Into<std::boxed::Box<crate::model::MultiplexedSessionPrecommitToken>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.multiplexed_session_retry = std::option::Option::Some(
            crate::model::commit_response::MultiplexedSessionRetry::PrecommitToken(v.into()),
        );
        self
    }
}

impl wkt::message::Message for CommitResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.CommitResponse"
    }
}

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

    /// Additional statistics about a commit.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct CommitStats {
        /// The total number of mutations for the transaction. Knowing the
        /// `mutation_count` value can help you maximize the number of mutations
        /// in a transaction and minimize the number of API round trips. You can
        /// also monitor this value to prevent transactions from exceeding the system
        /// [limit](https://cloud.google.com/spanner/quotas#limits_for_creating_reading_updating_and_deleting_data).
        /// If the number of mutations exceeds the limit, the server returns
        /// [INVALID_ARGUMENT](https://cloud.google.com/spanner/docs/reference/rest/v1/Code#ENUM_VALUES.INVALID_ARGUMENT).
        pub mutation_count: i64,

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

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

        /// Sets the value of [mutation_count][crate::model::commit_response::CommitStats::mutation_count].
        pub fn set_mutation_count<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
            self.mutation_count = v.into();
            self
        }
    }

    impl wkt::message::Message for CommitStats {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.CommitResponse.CommitStats"
        }
    }

    /// You must examine and retry the commit if the following is populated.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum MultiplexedSessionRetry {
        /// If specified, transaction has not committed yet.
        /// You must retry the commit with the new precommit token.
        PrecommitToken(std::boxed::Box<crate::model::MultiplexedSessionPrecommitToken>),
    }

    impl MultiplexedSessionRetry {
        /// Initializes the enum to the [PrecommitToken](Self::PrecommitToken) branch.
        pub fn from_precommit_token(
            value: impl std::convert::Into<
                std::boxed::Box<crate::model::MultiplexedSessionPrecommitToken>,
            >,
        ) -> Self {
            Self::PrecommitToken(value.into())
        }
    }
}

/// KeyRange represents a range of rows in a table or index.
///
/// A range has a start key and an end key. These keys can be open or
/// closed, indicating if the range includes rows with that key.
///
/// Keys are represented by lists, where the ith value in the list
/// corresponds to the ith component of the table or index primary key.
/// Individual values are encoded as described
/// [here][google.spanner.v1.TypeCode].
///
/// For example, consider the following table definition:
///
/// ```norust
/// CREATE TABLE UserEvents (
///   UserName STRING(MAX),
///   EventDate STRING(10)
/// ) PRIMARY KEY(UserName, EventDate);
/// ```
///
/// The following keys name rows in this table:
///
/// ```norust
/// ["Bob", "2014-09-23"]
/// ["Alfred", "2015-06-12"]
/// ```
///
/// Since the `UserEvents` table's `PRIMARY KEY` clause names two
/// columns, each `UserEvents` key has two elements; the first is the
/// `UserName`, and the second is the `EventDate`.
///
/// Key ranges with multiple components are interpreted
/// lexicographically by component using the table or index key's declared
/// sort order. For example, the following range returns all events for
/// user `"Bob"` that occurred in the year 2015:
///
/// ```norust
/// "start_closed": ["Bob", "2015-01-01"]
/// "end_closed": ["Bob", "2015-12-31"]
/// ```
///
/// Start and end keys can omit trailing key components. This affects the
/// inclusion and exclusion of rows that exactly match the provided key
/// components: if the key is closed, then rows that exactly match the
/// provided components are included; if the key is open, then rows
/// that exactly match are not included.
///
/// For example, the following range includes all events for `"Bob"` that
/// occurred during and after the year 2000:
///
/// ```norust
/// "start_closed": ["Bob", "2000-01-01"]
/// "end_closed": ["Bob"]
/// ```
///
/// The next example retrieves all events for `"Bob"`:
///
/// ```norust
/// "start_closed": ["Bob"]
/// "end_closed": ["Bob"]
/// ```
///
/// To retrieve events before the year 2000:
///
/// ```norust
/// "start_closed": ["Bob"]
/// "end_open": ["Bob", "2000-01-01"]
/// ```
///
/// The following range includes all rows in the table:
///
/// ```norust
/// "start_closed": []
/// "end_closed": []
/// ```
///
/// This range returns all users whose `UserName` begins with any
/// character from A to C:
///
/// ```norust
/// "start_closed": ["A"]
/// "end_open": ["D"]
/// ```
///
/// This range returns all users whose `UserName` begins with B:
///
/// ```norust
/// "start_closed": ["B"]
/// "end_open": ["C"]
/// ```
///
/// Key ranges honor column sort order. For example, suppose a table is
/// defined as follows:
///
/// ```norust
/// CREATE TABLE DescendingSortedTable {
///   Key INT64,
///   ...
/// ) PRIMARY KEY(Key DESC);
/// ```
///
/// The following range retrieves all rows with key values between 1
/// and 100 inclusive:
///
/// ```norust
/// "start_closed": ["100"]
/// "end_closed": ["1"]
/// ```
///
/// Note that 100 is passed as the start, and 1 is passed as the end,
/// because `Key` is a descending column in the schema.
///
/// [google.spanner.v1.TypeCode]: crate::model::TypeCode
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct KeyRange {
    /// The start key must be provided. It can be either closed or open.
    pub start_key_type: std::option::Option<crate::model::key_range::StartKeyType>,

    /// The end key must be provided. It can be either closed or open.
    pub end_key_type: std::option::Option<crate::model::key_range::EndKeyType>,

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

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

    /// Sets the value of [start_key_type][crate::model::KeyRange::start_key_type].
    ///
    /// Note that all the setters affecting `start_key_type` are mutually
    /// exclusive.
    pub fn set_start_key_type<
        T: std::convert::Into<std::option::Option<crate::model::key_range::StartKeyType>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.start_key_type = v.into();
        self
    }

    /// The value of [start_key_type][crate::model::KeyRange::start_key_type]
    /// if it holds a `StartClosed`, `None` if the field is not set or
    /// holds a different branch.
    pub fn start_closed(&self) -> std::option::Option<&std::boxed::Box<wkt::ListValue>> {
        #[allow(unreachable_patterns)]
        self.start_key_type.as_ref().and_then(|v| match v {
            crate::model::key_range::StartKeyType::StartClosed(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [start_key_type][crate::model::KeyRange::start_key_type]
    /// to hold a `StartClosed`.
    ///
    /// Note that all the setters affecting `start_key_type` are
    /// mutually exclusive.
    pub fn set_start_closed<T: std::convert::Into<std::boxed::Box<wkt::ListValue>>>(
        mut self,
        v: T,
    ) -> Self {
        self.start_key_type =
            std::option::Option::Some(crate::model::key_range::StartKeyType::StartClosed(v.into()));
        self
    }

    /// The value of [start_key_type][crate::model::KeyRange::start_key_type]
    /// if it holds a `StartOpen`, `None` if the field is not set or
    /// holds a different branch.
    pub fn start_open(&self) -> std::option::Option<&std::boxed::Box<wkt::ListValue>> {
        #[allow(unreachable_patterns)]
        self.start_key_type.as_ref().and_then(|v| match v {
            crate::model::key_range::StartKeyType::StartOpen(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [start_key_type][crate::model::KeyRange::start_key_type]
    /// to hold a `StartOpen`.
    ///
    /// Note that all the setters affecting `start_key_type` are
    /// mutually exclusive.
    pub fn set_start_open<T: std::convert::Into<std::boxed::Box<wkt::ListValue>>>(
        mut self,
        v: T,
    ) -> Self {
        self.start_key_type =
            std::option::Option::Some(crate::model::key_range::StartKeyType::StartOpen(v.into()));
        self
    }

    /// Sets the value of [end_key_type][crate::model::KeyRange::end_key_type].
    ///
    /// Note that all the setters affecting `end_key_type` are mutually
    /// exclusive.
    pub fn set_end_key_type<
        T: std::convert::Into<std::option::Option<crate::model::key_range::EndKeyType>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.end_key_type = v.into();
        self
    }

    /// The value of [end_key_type][crate::model::KeyRange::end_key_type]
    /// if it holds a `EndClosed`, `None` if the field is not set or
    /// holds a different branch.
    pub fn end_closed(&self) -> std::option::Option<&std::boxed::Box<wkt::ListValue>> {
        #[allow(unreachable_patterns)]
        self.end_key_type.as_ref().and_then(|v| match v {
            crate::model::key_range::EndKeyType::EndClosed(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [end_key_type][crate::model::KeyRange::end_key_type]
    /// to hold a `EndClosed`.
    ///
    /// Note that all the setters affecting `end_key_type` are
    /// mutually exclusive.
    pub fn set_end_closed<T: std::convert::Into<std::boxed::Box<wkt::ListValue>>>(
        mut self,
        v: T,
    ) -> Self {
        self.end_key_type =
            std::option::Option::Some(crate::model::key_range::EndKeyType::EndClosed(v.into()));
        self
    }

    /// The value of [end_key_type][crate::model::KeyRange::end_key_type]
    /// if it holds a `EndOpen`, `None` if the field is not set or
    /// holds a different branch.
    pub fn end_open(&self) -> std::option::Option<&std::boxed::Box<wkt::ListValue>> {
        #[allow(unreachable_patterns)]
        self.end_key_type.as_ref().and_then(|v| match v {
            crate::model::key_range::EndKeyType::EndOpen(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [end_key_type][crate::model::KeyRange::end_key_type]
    /// to hold a `EndOpen`.
    ///
    /// Note that all the setters affecting `end_key_type` are
    /// mutually exclusive.
    pub fn set_end_open<T: std::convert::Into<std::boxed::Box<wkt::ListValue>>>(
        mut self,
        v: T,
    ) -> Self {
        self.end_key_type =
            std::option::Option::Some(crate::model::key_range::EndKeyType::EndOpen(v.into()));
        self
    }
}

impl wkt::message::Message for KeyRange {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.KeyRange"
    }
}

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

    /// The start key must be provided. It can be either closed or open.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum StartKeyType {
        /// If the start is closed, then the range includes all rows whose
        /// first `len(start_closed)` key columns exactly match `start_closed`.
        StartClosed(std::boxed::Box<wkt::ListValue>),
        /// If the start is open, then the range excludes rows whose first
        /// `len(start_open)` key columns exactly match `start_open`.
        StartOpen(std::boxed::Box<wkt::ListValue>),
    }

    impl StartKeyType {
        /// Initializes the enum to the [StartClosed](Self::StartClosed) branch.
        pub fn from_start_closed(
            value: impl std::convert::Into<std::boxed::Box<wkt::ListValue>>,
        ) -> Self {
            Self::StartClosed(value.into())
        }
        /// Initializes the enum to the [StartOpen](Self::StartOpen) branch.
        pub fn from_start_open(
            value: impl std::convert::Into<std::boxed::Box<wkt::ListValue>>,
        ) -> Self {
            Self::StartOpen(value.into())
        }
    }

    /// The end key must be provided. It can be either closed or open.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum EndKeyType {
        /// If the end is closed, then the range includes all rows whose
        /// first `len(end_closed)` key columns exactly match `end_closed`.
        EndClosed(std::boxed::Box<wkt::ListValue>),
        /// If the end is open, then the range excludes rows whose first
        /// `len(end_open)` key columns exactly match `end_open`.
        EndOpen(std::boxed::Box<wkt::ListValue>),
    }

    impl EndKeyType {
        /// Initializes the enum to the [EndClosed](Self::EndClosed) branch.
        pub fn from_end_closed(
            value: impl std::convert::Into<std::boxed::Box<wkt::ListValue>>,
        ) -> Self {
            Self::EndClosed(value.into())
        }
        /// Initializes the enum to the [EndOpen](Self::EndOpen) branch.
        pub fn from_end_open(
            value: impl std::convert::Into<std::boxed::Box<wkt::ListValue>>,
        ) -> Self {
            Self::EndOpen(value.into())
        }
    }
}

/// `KeySet` defines a collection of Cloud Spanner keys and/or key ranges. All
/// the keys are expected to be in the same table or index. The keys need
/// not be sorted in any particular way.
///
/// If the same key is specified multiple times in the set (for example
/// if two ranges, two keys, or a key and a range overlap), Cloud Spanner
/// behaves as if the key were only specified once.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct KeySet {
    /// A list of specific keys. Entries in `keys` should have exactly as
    /// many elements as there are columns in the primary or index key
    /// with which this `KeySet` is used.  Individual key values are
    /// encoded as described [here][google.spanner.v1.TypeCode].
    ///
    /// [google.spanner.v1.TypeCode]: crate::model::TypeCode
    pub keys: std::vec::Vec<wkt::ListValue>,

    /// A list of key ranges. See [KeyRange][google.spanner.v1.KeyRange] for more
    /// information about key range specifications.
    ///
    /// [google.spanner.v1.KeyRange]: crate::model::KeyRange
    pub ranges: std::vec::Vec<crate::model::KeyRange>,

    /// For convenience `all` can be set to `true` to indicate that this
    /// `KeySet` matches all keys in the table or index. Note that any keys
    /// specified in `keys` or `ranges` are only yielded once.
    pub all: bool,

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

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

    /// Sets the value of [keys][crate::model::KeySet::keys].
    pub fn set_keys<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<wkt::ListValue>,
    {
        use std::iter::Iterator;
        self.keys = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [ranges][crate::model::KeySet::ranges].
    pub fn set_ranges<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::KeyRange>,
    {
        use std::iter::Iterator;
        self.ranges = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [all][crate::model::KeySet::all].
    pub fn set_all<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.all = v.into();
        self
    }
}

impl wkt::message::Message for KeySet {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.KeySet"
    }
}

/// A `Range` represents a range of keys in a database. The keys themselves
/// are encoded in "sortable string format", also known as ssformat. Consult
/// Spanner's open source client libraries for details on the encoding.
///
/// Each range represents a contiguous range of rows, possibly from multiple
/// tables/indexes. Each range is associated with a single paxos group (known as
/// a "group" throughout this API), a split (which names the exact range within
/// the group), and a generation that can be used to determine whether a given
/// `Range` represents a newer or older location for the key range.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Range {
    /// The start key of the range, inclusive. Encoded in "sortable string format"
    /// (ssformat).
    pub start_key: ::bytes::Bytes,

    /// The limit key of the range, exclusive. Encoded in "sortable string format"
    /// (ssformat).
    pub limit_key: ::bytes::Bytes,

    /// The UID of the paxos group where this range is stored. UIDs are unique
    /// within the database. References `Group.group_uid`.
    pub group_uid: u64,

    /// A group can store multiple ranges of keys. Each key range is named by an
    /// ID (the split ID). Within a group, split IDs are unique. The `split_id`
    /// names the exact split in `group_uid` where this range is stored.
    pub split_id: u64,

    /// `generation` indicates the freshness of the range information contained
    /// in this proto. Generations can be compared lexicographically; if generation
    /// A is greater than generation B, then the `Range` corresponding to A is
    /// newer than the `Range` corresponding to B, and should be used
    /// preferentially.
    pub generation: ::bytes::Bytes,

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

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

    /// Sets the value of [start_key][crate::model::Range::start_key].
    pub fn set_start_key<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.start_key = v.into();
        self
    }

    /// Sets the value of [limit_key][crate::model::Range::limit_key].
    pub fn set_limit_key<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.limit_key = v.into();
        self
    }

    /// Sets the value of [group_uid][crate::model::Range::group_uid].
    pub fn set_group_uid<T: std::convert::Into<u64>>(mut self, v: T) -> Self {
        self.group_uid = v.into();
        self
    }

    /// Sets the value of [split_id][crate::model::Range::split_id].
    pub fn set_split_id<T: std::convert::Into<u64>>(mut self, v: T) -> Self {
        self.split_id = v.into();
        self
    }

    /// Sets the value of [generation][crate::model::Range::generation].
    pub fn set_generation<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.generation = v.into();
        self
    }
}

impl wkt::message::Message for Range {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.Range"
    }
}

/// A `Tablet` represents a single replica of a `Group`. A tablet is served by a
/// single server at a time, and can move between servers due to server death or
/// simply load balancing.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Tablet {
    /// The UID of the tablet, unique within the database. Matches the
    /// `tablet_uids` and `leader_tablet_uid` fields in `Group`.
    pub tablet_uid: u64,

    /// The address of the server that is serving this tablet -- either an IP
    /// address or DNS hostname and a port number.
    pub server_address: std::string::String,

    /// Where this tablet is located. This is the name of a Google Cloud region,
    /// such as "us-central1".
    pub location: std::string::String,

    /// The role of the tablet.
    pub role: crate::model::tablet::Role,

    /// `incarnation` indicates the freshness of the tablet information contained
    /// in this proto. Incarnations can be compared lexicographically; if
    /// incarnation A is greater than incarnation B, then the `Tablet`
    /// corresponding to A is newer than the `Tablet` corresponding to B, and
    /// should be used preferentially.
    pub incarnation: ::bytes::Bytes,

    /// Distances help the client pick the closest tablet out of the list of
    /// tablets for a given request. Tablets with lower distances should generally
    /// be preferred. Tablets with the same distance are approximately equally
    /// close; the client can choose arbitrarily.
    ///
    /// Distances do not correspond precisely to expected latency, geographical
    /// distance, or anything else. Distances should be compared only between
    /// tablets of the same group; they are not meaningful between different
    /// groups.
    ///
    /// A value of zero indicates that the tablet may be in the same zone as
    /// the client, and have minimum network latency. A value less than or equal to
    /// five indicates that the tablet is thought to be in the same region as the
    /// client, and may have a few milliseconds of network latency. Values greater
    /// than five are most likely in a different region, with non-trivial network
    /// latency.
    ///
    /// Clients should use the following algorithm:
    ///
    /// * If the request is using a directed read, eliminate any tablets that
    ///   do not match the directed read's target zone and/or replica type.
    /// * (Read-write transactions only) Choose leader tablet if it has an
    ///   distance <=5.
    /// * Group and sort tablets by distance. Choose a random
    ///   tablet with the lowest distance. If the request
    ///   is not a directed read, only consider replicas with distances <=5.
    /// * Send the request to the fallback endpoint.
    ///
    /// The tablet picked by this algorithm may be skipped, either because it is
    /// marked as `skip` by the server or because the corresponding server is
    /// unreachable, flow controlled, etc. Skipped tablets should be added to the
    /// `skipped_tablet_uid` field in `RoutingHint`; the algorithm above should
    /// then be re-run without including the skipped tablet(s) to pick the next
    /// best tablet.
    pub distance: u32,

    /// If true, the tablet should not be chosen by the client. Typically, this
    /// signals that the tablet is unhealthy in some way. Tablets with `skip`
    /// set to true should be reported back to the server in
    /// `RoutingHint.skipped_tablet_uid`; this cues the server to send updated
    /// information for this tablet should it become usable again.
    pub skip: bool,

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

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

    /// Sets the value of [tablet_uid][crate::model::Tablet::tablet_uid].
    pub fn set_tablet_uid<T: std::convert::Into<u64>>(mut self, v: T) -> Self {
        self.tablet_uid = v.into();
        self
    }

    /// Sets the value of [server_address][crate::model::Tablet::server_address].
    pub fn set_server_address<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.server_address = v.into();
        self
    }

    /// Sets the value of [location][crate::model::Tablet::location].
    pub fn set_location<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.location = v.into();
        self
    }

    /// Sets the value of [role][crate::model::Tablet::role].
    pub fn set_role<T: std::convert::Into<crate::model::tablet::Role>>(mut self, v: T) -> Self {
        self.role = v.into();
        self
    }

    /// Sets the value of [incarnation][crate::model::Tablet::incarnation].
    pub fn set_incarnation<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.incarnation = v.into();
        self
    }

    /// Sets the value of [distance][crate::model::Tablet::distance].
    pub fn set_distance<T: std::convert::Into<u32>>(mut self, v: T) -> Self {
        self.distance = v.into();
        self
    }

    /// Sets the value of [skip][crate::model::Tablet::skip].
    pub fn set_skip<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.skip = v.into();
        self
    }
}

impl wkt::message::Message for Tablet {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.Tablet"
    }
}

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

    /// Indicates the role of the tablet.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Role {
        /// Not specified.
        Unspecified,
        /// The tablet can perform reads and (if elected leader) writes.
        ReadWrite,
        /// The tablet can only perform reads.
        ReadOnly,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Role::value] or
        /// [Role::name].
        UnknownValue(role::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for Role {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::ReadWrite,
                2 => Self::ReadOnly,
                _ => Self::UnknownValue(role::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Role {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "ROLE_UNSPECIFIED" => Self::Unspecified,
                "READ_WRITE" => Self::ReadWrite,
                "READ_ONLY" => Self::ReadOnly,
                _ => Self::UnknownValue(role::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// A `Group` represents a paxos group in a database. A group is a set of
/// tablets that are replicated across multiple servers. Groups may have a leader
/// tablet. Groups store one (or sometimes more) ranges of keys.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Group {
    /// The UID of the paxos group, unique within the database. Matches the
    /// `group_uid` field in `Range`.
    pub group_uid: u64,

    /// A list of tablets that are part of the group. Note that this list may not
    /// be exhaustive; it will only include tablets the server considers useful
    /// to the client. The returned list is ordered ascending by distance.
    ///
    /// Tablet UIDs reference `Tablet.tablet_uid`.
    pub tablets: std::vec::Vec<crate::model::Tablet>,

    /// The last known leader tablet of the group as an index into `tablets`. May
    /// be negative if the group has no known leader.
    pub leader_index: i32,

    /// `generation` indicates the freshness of the group information (including
    /// leader information) contained in this proto. Generations can be compared
    /// lexicographically; if generation A is greater than generation B, then the
    /// `Group` corresponding to A is newer than the `Group` corresponding to B,
    /// and should be used preferentially.
    pub generation: ::bytes::Bytes,

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

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

    /// Sets the value of [group_uid][crate::model::Group::group_uid].
    pub fn set_group_uid<T: std::convert::Into<u64>>(mut self, v: T) -> Self {
        self.group_uid = v.into();
        self
    }

    /// Sets the value of [tablets][crate::model::Group::tablets].
    pub fn set_tablets<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Tablet>,
    {
        use std::iter::Iterator;
        self.tablets = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [leader_index][crate::model::Group::leader_index].
    pub fn set_leader_index<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.leader_index = v.into();
        self
    }

    /// Sets the value of [generation][crate::model::Group::generation].
    pub fn set_generation<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.generation = v.into();
        self
    }
}

impl wkt::message::Message for Group {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.Group"
    }
}

/// A `KeyRecipe` provides the metadata required to translate reads, mutations,
/// and queries into a byte array in "sortable string format" (ssformat)that can
/// be used with `Range`s to route requests. Note that the client *must* tolerate
/// `KeyRecipe`s that appear to be invalid, since the `KeyRecipe` format may
/// change over time. Requests with invalid `KeyRecipe`s should be routed to a
/// default server.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct KeyRecipe {
    /// Parts are in the order they should appear in the encoded key.
    pub part: std::vec::Vec<crate::model::key_recipe::Part>,

    /// A recipe can be associated with a table, index, or query. Tables recipes
    /// are used to encode read and write keys; index recipes are used for index
    /// reads, and query recipes are used only for SQL queries.
    pub target: std::option::Option<crate::model::key_recipe::Target>,

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

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

    /// Sets the value of [part][crate::model::KeyRecipe::part].
    pub fn set_part<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::key_recipe::Part>,
    {
        use std::iter::Iterator;
        self.part = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [target][crate::model::KeyRecipe::target].
    ///
    /// Note that all the setters affecting `target` are mutually
    /// exclusive.
    pub fn set_target<
        T: std::convert::Into<std::option::Option<crate::model::key_recipe::Target>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.target = v.into();
        self
    }

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

    /// Sets the value of [target][crate::model::KeyRecipe::target]
    /// to hold a `TableName`.
    ///
    /// Note that all the setters affecting `target` are
    /// mutually exclusive.
    pub fn set_table_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.target =
            std::option::Option::Some(crate::model::key_recipe::Target::TableName(v.into()));
        self
    }

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

    /// Sets the value of [target][crate::model::KeyRecipe::target]
    /// to hold a `IndexName`.
    ///
    /// Note that all the setters affecting `target` are
    /// mutually exclusive.
    pub fn set_index_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.target =
            std::option::Option::Some(crate::model::key_recipe::Target::IndexName(v.into()));
        self
    }

    /// The value of [target][crate::model::KeyRecipe::target]
    /// if it holds a `OperationUid`, `None` if the field is not set or
    /// holds a different branch.
    pub fn operation_uid(&self) -> std::option::Option<&u64> {
        #[allow(unreachable_patterns)]
        self.target.as_ref().and_then(|v| match v {
            crate::model::key_recipe::Target::OperationUid(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [target][crate::model::KeyRecipe::target]
    /// to hold a `OperationUid`.
    ///
    /// Note that all the setters affecting `target` are
    /// mutually exclusive.
    pub fn set_operation_uid<T: std::convert::Into<u64>>(mut self, v: T) -> Self {
        self.target =
            std::option::Option::Some(crate::model::key_recipe::Target::OperationUid(v.into()));
        self
    }
}

impl wkt::message::Message for KeyRecipe {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.KeyRecipe"
    }
}

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

    /// An ssformat key is composed of a sequence of tag numbers and key column
    /// values. `Part` represents a single tag or key column value.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Part {
        /// If non-zero, `tag` is the only field present in this `Part`. The part
        /// is encoded by appending `tag` to the ssformat key.
        pub tag: u32,

        /// Whether the key column is sorted ascending or descending. Only present
        /// if `tag` is zero.
        pub order: crate::model::key_recipe::part::Order,

        /// How NULLs are represented in the encoded key part. Only present if `tag`
        /// is zero.
        pub null_order: crate::model::key_recipe::part::NullOrder,

        /// The type of the key part. Only present if `tag` is zero.
        pub r#type: std::option::Option<crate::model::Type>,

        /// It is a repeated field to support fetching key columns from nested
        /// structs, such as `STRUCT` query parameters.
        pub struct_identifiers: std::vec::Vec<i32>,

        /// Only present if `tag` is zero.
        pub value_type: std::option::Option<crate::model::key_recipe::part::ValueType>,

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

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

        /// Sets the value of [tag][crate::model::key_recipe::Part::tag].
        pub fn set_tag<T: std::convert::Into<u32>>(mut self, v: T) -> Self {
            self.tag = v.into();
            self
        }

        /// Sets the value of [order][crate::model::key_recipe::Part::order].
        pub fn set_order<T: std::convert::Into<crate::model::key_recipe::part::Order>>(
            mut self,
            v: T,
        ) -> Self {
            self.order = v.into();
            self
        }

        /// Sets the value of [null_order][crate::model::key_recipe::Part::null_order].
        pub fn set_null_order<T: std::convert::Into<crate::model::key_recipe::part::NullOrder>>(
            mut self,
            v: T,
        ) -> Self {
            self.null_order = v.into();
            self
        }

        /// Sets the value of [r#type][crate::model::key_recipe::Part::type].
        pub fn set_type<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::Type>,
        {
            self.r#type = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [r#type][crate::model::key_recipe::Part::type].
        pub fn set_or_clear_type<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::Type>,
        {
            self.r#type = v.map(|x| x.into());
            self
        }

        /// Sets the value of [struct_identifiers][crate::model::key_recipe::Part::struct_identifiers].
        pub fn set_struct_identifiers<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<i32>,
        {
            use std::iter::Iterator;
            self.struct_identifiers = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [value_type][crate::model::key_recipe::Part::value_type].
        ///
        /// Note that all the setters affecting `value_type` are mutually
        /// exclusive.
        pub fn set_value_type<
            T: std::convert::Into<std::option::Option<crate::model::key_recipe::part::ValueType>>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.value_type = v.into();
            self
        }

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

        /// Sets the value of [value_type][crate::model::key_recipe::Part::value_type]
        /// to hold a `Identifier`.
        ///
        /// Note that all the setters affecting `value_type` are
        /// mutually exclusive.
        pub fn set_identifier<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.value_type = std::option::Option::Some(
                crate::model::key_recipe::part::ValueType::Identifier(v.into()),
            );
            self
        }

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

        /// Sets the value of [value_type][crate::model::key_recipe::Part::value_type]
        /// to hold a `Value`.
        ///
        /// Note that all the setters affecting `value_type` are
        /// mutually exclusive.
        pub fn set_value<T: std::convert::Into<std::boxed::Box<wkt::Value>>>(
            mut self,
            v: T,
        ) -> Self {
            self.value_type = std::option::Option::Some(
                crate::model::key_recipe::part::ValueType::Value(v.into()),
            );
            self
        }

        /// The value of [value_type][crate::model::key_recipe::Part::value_type]
        /// if it holds a `Random`, `None` if the field is not set or
        /// holds a different branch.
        pub fn random(&self) -> std::option::Option<&bool> {
            #[allow(unreachable_patterns)]
            self.value_type.as_ref().and_then(|v| match v {
                crate::model::key_recipe::part::ValueType::Random(v) => {
                    std::option::Option::Some(v)
                }
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [value_type][crate::model::key_recipe::Part::value_type]
        /// to hold a `Random`.
        ///
        /// Note that all the setters affecting `value_type` are
        /// mutually exclusive.
        pub fn set_random<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.value_type = std::option::Option::Some(
                crate::model::key_recipe::part::ValueType::Random(v.into()),
            );
            self
        }
    }

    impl wkt::message::Message for Part {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.KeyRecipe.Part"
        }
    }

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

        /// The remaining fields encode column values.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Order {
            /// Default value, equivalent to `ASCENDING`.
            Unspecified,
            /// The key is ascending - corresponds to `ASC` in the schema definition.
            Ascending,
            /// The key is descending - corresponds to `DESC` in the schema definition.
            Descending,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [Order::value] or
            /// [Order::name].
            UnknownValue(order::UnknownValue),
        }

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

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

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

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

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

        impl std::convert::From<i32> for Order {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::Ascending,
                    2 => Self::Descending,
                    _ => Self::UnknownValue(order::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for Order {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "ORDER_UNSPECIFIED" => Self::Unspecified,
                    "ASCENDING" => Self::Ascending,
                    "DESCENDING" => Self::Descending,
                    _ => Self::UnknownValue(order::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

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

        impl<'de> serde::de::Deserialize<'de> for Order {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<Order>::new(
                    ".google.spanner.v1.KeyRecipe.Part.Order",
                ))
            }
        }

        /// The null order of the key column. This dictates where NULL values sort
        /// in the sorted order. Note that columns which are `NOT NULL` can have a
        /// special encoding.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum NullOrder {
            /// Default value. This value is unused.
            Unspecified,
            /// NULL values sort before any non-NULL values.
            NullsFirst,
            /// NULL values sort after any non-NULL values.
            NullsLast,
            /// The column does not support NULL values.
            NotNull,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [NullOrder::value] or
            /// [NullOrder::name].
            UnknownValue(null_order::UnknownValue),
        }

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

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

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

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

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

        impl std::convert::From<i32> for NullOrder {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::NullsFirst,
                    2 => Self::NullsLast,
                    3 => Self::NotNull,
                    _ => Self::UnknownValue(null_order::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for NullOrder {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "NULL_ORDER_UNSPECIFIED" => Self::Unspecified,
                    "NULLS_FIRST" => Self::NullsFirst,
                    "NULLS_LAST" => Self::NullsLast,
                    "NOT_NULL" => Self::NotNull,
                    _ => Self::UnknownValue(null_order::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

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

        impl<'de> serde::de::Deserialize<'de> for NullOrder {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<NullOrder>::new(
                    ".google.spanner.v1.KeyRecipe.Part.NullOrder",
                ))
            }
        }

        /// Only present if `tag` is zero.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum ValueType {
            /// `identifier` is the name of the column or query parameter.
            Identifier(std::string::String),
            /// The constant value of the key part.
            /// It is present when query uses a constant as a part of the key.
            Value(std::boxed::Box<wkt::Value>),
            /// If true, the client is responsible to fill in the value randomly.
            /// It's relevant only for the INT64 type.
            Random(bool),
        }

        impl ValueType {
            /// Initializes the enum to the [Identifier](Self::Identifier) branch.
            pub fn from_identifier(value: impl std::convert::Into<std::string::String>) -> Self {
                Self::Identifier(value.into())
            }
            /// Initializes the enum to the [Value](Self::Value) branch.
            pub fn from_value(value: impl std::convert::Into<std::boxed::Box<wkt::Value>>) -> Self {
                Self::Value(value.into())
            }
            /// Initializes the enum to the [Random](Self::Random) branch.
            pub fn from_random(value: impl std::convert::Into<bool>) -> Self {
                Self::Random(value.into())
            }
        }
    }

    /// A recipe can be associated with a table, index, or query. Tables recipes
    /// are used to encode read and write keys; index recipes are used for index
    /// reads, and query recipes are used only for SQL queries.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Target {
        /// A table name, matching the name from the database schema.
        TableName(std::string::String),
        /// An index name, matching the name from the database schema.
        IndexName(std::string::String),
        /// The UID of a query, matching the UID from `RoutingHint`.
        OperationUid(u64),
    }

    impl Target {
        /// Initializes the enum to the [TableName](Self::TableName) branch.
        pub fn from_table_name(value: impl std::convert::Into<std::string::String>) -> Self {
            Self::TableName(value.into())
        }
        /// Initializes the enum to the [IndexName](Self::IndexName) branch.
        pub fn from_index_name(value: impl std::convert::Into<std::string::String>) -> Self {
            Self::IndexName(value.into())
        }
        /// Initializes the enum to the [OperationUid](Self::OperationUid) branch.
        pub fn from_operation_uid(value: impl std::convert::Into<u64>) -> Self {
            Self::OperationUid(value.into())
        }
    }
}

/// A `RecipeList` contains a list of `KeyRecipe`s, which share the same
/// schema generation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RecipeList {
    /// The schema generation of the recipes. To be sent to the server in
    /// `RoutingHint.schema_generation` whenever one of the recipes is used.
    /// `schema_generation` values are comparable with each other; if generation A
    /// compares greater than generation B, then A is a more recent schema than B.
    /// Clients should in general aim to cache only the latest schema generation,
    /// and discard more stale recipes.
    pub schema_generation: ::bytes::Bytes,

    /// A list of recipes to be cached.
    pub recipe: std::vec::Vec<crate::model::KeyRecipe>,

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

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

    /// Sets the value of [schema_generation][crate::model::RecipeList::schema_generation].
    pub fn set_schema_generation<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.schema_generation = v.into();
        self
    }

    /// Sets the value of [recipe][crate::model::RecipeList::recipe].
    pub fn set_recipe<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::KeyRecipe>,
    {
        use std::iter::Iterator;
        self.recipe = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for RecipeList {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.RecipeList"
    }
}

/// A `CacheUpdate` expresses a set of changes the client should incorporate into
/// its location cache. These changes may or may not be newer than what the
/// client has in its cache, and should be discarded if necessary. `CacheUpdate`s
/// can be obtained in response to requests that included a `RoutingHint`
/// field, but may also be obtained by explicit location-fetching RPCs which may
/// be added in the future.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CacheUpdate {
    /// An internal ID for the database. Database names can be reused if a database
    /// is deleted and re-created. Each time the database is re-created, it will
    /// get a new database ID, which will never be re-used for any other database.
    pub database_id: u64,

    /// A list of ranges to be cached.
    pub range: std::vec::Vec<crate::model::Range>,

    /// A list of groups to be cached.
    pub group: std::vec::Vec<crate::model::Group>,

    /// A list of recipes to be cached.
    pub key_recipes: std::option::Option<crate::model::RecipeList>,

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

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

    /// Sets the value of [database_id][crate::model::CacheUpdate::database_id].
    pub fn set_database_id<T: std::convert::Into<u64>>(mut self, v: T) -> Self {
        self.database_id = v.into();
        self
    }

    /// Sets the value of [range][crate::model::CacheUpdate::range].
    pub fn set_range<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Range>,
    {
        use std::iter::Iterator;
        self.range = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [group][crate::model::CacheUpdate::group].
    pub fn set_group<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Group>,
    {
        use std::iter::Iterator;
        self.group = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [key_recipes][crate::model::CacheUpdate::key_recipes].
    pub fn set_key_recipes<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RecipeList>,
    {
        self.key_recipes = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [key_recipes][crate::model::CacheUpdate::key_recipes].
    pub fn set_or_clear_key_recipes<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RecipeList>,
    {
        self.key_recipes = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for CacheUpdate {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.CacheUpdate"
    }
}

/// `RoutingHint` can be optionally added to location-aware Spanner
/// requests. It gives the server hints that can be used to route the request to
/// an appropriate server, potentially significantly decreasing latency and
/// improving throughput. To achieve improved performance, most fields must be
/// filled in with accurate values.
///
/// The presence of a valid `RoutingHint` tells the server that the client
/// is location-aware.
///
/// `RoutingHint` does not change the semantics of the request; it is
/// purely a performance hint; the request will perform the same actions on the
/// database's data as if `RoutingHint` were not present. However, if
/// the `RoutingHint` is incomplete or incorrect, the response may include
/// a `CacheUpdate` the client can use to correct its location cache.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RoutingHint {
    /// A session-scoped unique ID for the operation, computed client-side.
    /// Requests with the same `operation_uid` should have a shared 'shape',
    /// meaning that some fields are expected to be the same, such as the SQL
    /// query, the target table/columns (for reads) etc. Requests with the same
    /// `operation_uid` are meant to differ only in fields like keys/key
    /// ranges/query parameters, transaction IDs, etc.
    ///
    /// `operation_uid` must be non-zero for `RoutingHint` to be valid.
    pub operation_uid: u64,

    /// The database ID of the database being accessed, see
    /// `CacheUpdate.database_id`. Should match the cache entries that were used
    /// to generate the rest of the fields in this `RoutingHint`.
    pub database_id: u64,

    /// The schema generation of the recipe that was used to generate `key` and
    /// `limit_key`. See also `RecipeList.schema_generation`.
    pub schema_generation: ::bytes::Bytes,

    /// The key / key range that this request accesses. For operations that
    /// access a single key, `key` should be set and `limit_key` should be empty.
    /// For operations that access a key range, `key` and `limit_key` should both
    /// be set, to the inclusive start and exclusive end of the range respectively.
    ///
    /// The keys are encoded in "sortable string format" (ssformat), using a
    /// `KeyRecipe` that is appropriate for the request. See `KeyRecipe` for more
    /// details.
    pub key: ::bytes::Bytes,

    /// If this request targets a key range, this is the exclusive end of the
    /// range. See `key` for more details.
    pub limit_key: ::bytes::Bytes,

    /// The group UID of the group that the client believes serves the range
    /// defined by `key` and `limit_key`. See `Range.group_uid` for more details.
    pub group_uid: u64,

    /// The split ID of the split that the client believes contains the range
    /// defined by `key` and `limit_key`. See `Range.split_id` for more details.
    pub split_id: u64,

    /// The tablet UID of the tablet from group `group_uid` that the client
    /// believes is best to serve this request. See `Group.local_tablet_uids` and
    /// `Group.leader_tablet_uid`.
    pub tablet_uid: u64,

    /// If the client had multiple options for tablet selection, and some of its
    /// first choices were unhealthy (e.g., the server is unreachable, or
    /// `Tablet.skip` is true), this field will contain the tablet UIDs of those
    /// tablets, with their incarnations. The server may include a `CacheUpdate`
    /// with new locations for those tablets.
    pub skipped_tablet_uid: std::vec::Vec<crate::model::routing_hint::SkippedTablet>,

    /// If present, the client's current location. This should be the name of a
    /// Google Cloud zone or region, such as "us-central1".
    ///
    /// If absent, the client's location will be assumed to be the same as the
    /// location of the server the client ends up connected to.
    ///
    /// Locations are primarily valuable for clients that connect from regions
    /// other than the ones that contain the Spanner database.
    pub client_location: std::string::String,

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

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

    /// Sets the value of [operation_uid][crate::model::RoutingHint::operation_uid].
    pub fn set_operation_uid<T: std::convert::Into<u64>>(mut self, v: T) -> Self {
        self.operation_uid = v.into();
        self
    }

    /// Sets the value of [database_id][crate::model::RoutingHint::database_id].
    pub fn set_database_id<T: std::convert::Into<u64>>(mut self, v: T) -> Self {
        self.database_id = v.into();
        self
    }

    /// Sets the value of [schema_generation][crate::model::RoutingHint::schema_generation].
    pub fn set_schema_generation<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.schema_generation = v.into();
        self
    }

    /// Sets the value of [key][crate::model::RoutingHint::key].
    pub fn set_key<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.key = v.into();
        self
    }

    /// Sets the value of [limit_key][crate::model::RoutingHint::limit_key].
    pub fn set_limit_key<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.limit_key = v.into();
        self
    }

    /// Sets the value of [group_uid][crate::model::RoutingHint::group_uid].
    pub fn set_group_uid<T: std::convert::Into<u64>>(mut self, v: T) -> Self {
        self.group_uid = v.into();
        self
    }

    /// Sets the value of [split_id][crate::model::RoutingHint::split_id].
    pub fn set_split_id<T: std::convert::Into<u64>>(mut self, v: T) -> Self {
        self.split_id = v.into();
        self
    }

    /// Sets the value of [tablet_uid][crate::model::RoutingHint::tablet_uid].
    pub fn set_tablet_uid<T: std::convert::Into<u64>>(mut self, v: T) -> Self {
        self.tablet_uid = v.into();
        self
    }

    /// Sets the value of [skipped_tablet_uid][crate::model::RoutingHint::skipped_tablet_uid].
    pub fn set_skipped_tablet_uid<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::routing_hint::SkippedTablet>,
    {
        use std::iter::Iterator;
        self.skipped_tablet_uid = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [client_location][crate::model::RoutingHint::client_location].
    pub fn set_client_location<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.client_location = v.into();
        self
    }
}

impl wkt::message::Message for RoutingHint {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.RoutingHint"
    }
}

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

    /// A tablet that was skipped by the client. See `Tablet.tablet_uid` and
    /// `Tablet.incarnation`.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct SkippedTablet {
        /// The tablet UID of the tablet that was skipped. See `Tablet.tablet_uid`.
        pub tablet_uid: u64,

        /// The incarnation of the tablet that was skipped. See `Tablet.incarnation`.
        pub incarnation: ::bytes::Bytes,

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

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

        /// Sets the value of [tablet_uid][crate::model::routing_hint::SkippedTablet::tablet_uid].
        pub fn set_tablet_uid<T: std::convert::Into<u64>>(mut self, v: T) -> Self {
            self.tablet_uid = v.into();
            self
        }

        /// Sets the value of [incarnation][crate::model::routing_hint::SkippedTablet::incarnation].
        pub fn set_incarnation<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
            self.incarnation = v.into();
            self
        }
    }

    impl wkt::message::Message for SkippedTablet {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.RoutingHint.SkippedTablet"
        }
    }
}

/// A modification to one or more Cloud Spanner rows.  Mutations can be
/// applied to a Cloud Spanner database by sending them in a
/// [Commit][google.spanner.v1.Spanner.Commit] call.
///
/// [google.spanner.v1.Spanner.Commit]: crate::client::Spanner::commit
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Mutation {
    /// Required. The operation to perform.
    pub operation: std::option::Option<crate::model::mutation::Operation>,

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

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

    /// Sets the value of [operation][crate::model::Mutation::operation].
    ///
    /// Note that all the setters affecting `operation` are mutually
    /// exclusive.
    pub fn set_operation<
        T: std::convert::Into<std::option::Option<crate::model::mutation::Operation>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.operation = v.into();
        self
    }

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

    /// Sets the value of [operation][crate::model::Mutation::operation]
    /// to hold a `Insert`.
    ///
    /// Note that all the setters affecting `operation` are
    /// mutually exclusive.
    pub fn set_insert<T: std::convert::Into<std::boxed::Box<crate::model::mutation::Write>>>(
        mut self,
        v: T,
    ) -> Self {
        self.operation =
            std::option::Option::Some(crate::model::mutation::Operation::Insert(v.into()));
        self
    }

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

    /// Sets the value of [operation][crate::model::Mutation::operation]
    /// to hold a `Update`.
    ///
    /// Note that all the setters affecting `operation` are
    /// mutually exclusive.
    pub fn set_update<T: std::convert::Into<std::boxed::Box<crate::model::mutation::Write>>>(
        mut self,
        v: T,
    ) -> Self {
        self.operation =
            std::option::Option::Some(crate::model::mutation::Operation::Update(v.into()));
        self
    }

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

    /// Sets the value of [operation][crate::model::Mutation::operation]
    /// to hold a `InsertOrUpdate`.
    ///
    /// Note that all the setters affecting `operation` are
    /// mutually exclusive.
    pub fn set_insert_or_update<
        T: std::convert::Into<std::boxed::Box<crate::model::mutation::Write>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.operation =
            std::option::Option::Some(crate::model::mutation::Operation::InsertOrUpdate(v.into()));
        self
    }

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

    /// Sets the value of [operation][crate::model::Mutation::operation]
    /// to hold a `Replace`.
    ///
    /// Note that all the setters affecting `operation` are
    /// mutually exclusive.
    pub fn set_replace<T: std::convert::Into<std::boxed::Box<crate::model::mutation::Write>>>(
        mut self,
        v: T,
    ) -> Self {
        self.operation =
            std::option::Option::Some(crate::model::mutation::Operation::Replace(v.into()));
        self
    }

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

    /// Sets the value of [operation][crate::model::Mutation::operation]
    /// to hold a `Delete`.
    ///
    /// Note that all the setters affecting `operation` are
    /// mutually exclusive.
    pub fn set_delete<T: std::convert::Into<std::boxed::Box<crate::model::mutation::Delete>>>(
        mut self,
        v: T,
    ) -> Self {
        self.operation =
            std::option::Option::Some(crate::model::mutation::Operation::Delete(v.into()));
        self
    }

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

    /// Sets the value of [operation][crate::model::Mutation::operation]
    /// to hold a `Send`.
    ///
    /// Note that all the setters affecting `operation` are
    /// mutually exclusive.
    pub fn set_send<T: std::convert::Into<std::boxed::Box<crate::model::mutation::Send>>>(
        mut self,
        v: T,
    ) -> Self {
        self.operation =
            std::option::Option::Some(crate::model::mutation::Operation::Send(v.into()));
        self
    }

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

    /// Sets the value of [operation][crate::model::Mutation::operation]
    /// to hold a `Ack`.
    ///
    /// Note that all the setters affecting `operation` are
    /// mutually exclusive.
    pub fn set_ack<T: std::convert::Into<std::boxed::Box<crate::model::mutation::Ack>>>(
        mut self,
        v: T,
    ) -> Self {
        self.operation =
            std::option::Option::Some(crate::model::mutation::Operation::Ack(v.into()));
        self
    }
}

impl wkt::message::Message for Mutation {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.Mutation"
    }
}

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

    /// Arguments to [insert][google.spanner.v1.Mutation.insert],
    /// [update][google.spanner.v1.Mutation.update],
    /// [insert_or_update][google.spanner.v1.Mutation.insert_or_update], and
    /// [replace][google.spanner.v1.Mutation.replace] operations.
    ///
    /// [google.spanner.v1.Mutation.insert]: crate::model::Mutation::operation
    /// [google.spanner.v1.Mutation.insert_or_update]: crate::model::Mutation::operation
    /// [google.spanner.v1.Mutation.replace]: crate::model::Mutation::operation
    /// [google.spanner.v1.Mutation.update]: crate::model::Mutation::operation
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Write {
        /// Required. The table whose rows will be written.
        pub table: std::string::String,

        /// The names of the columns in
        /// [table][google.spanner.v1.Mutation.Write.table] to be written.
        ///
        /// The list of columns must contain enough columns to allow
        /// Cloud Spanner to derive values for all primary key columns in the
        /// row(s) to be modified.
        ///
        /// [google.spanner.v1.Mutation.Write.table]: crate::model::mutation::Write::table
        pub columns: std::vec::Vec<std::string::String>,

        /// The values to be written. `values` can contain more than one
        /// list of values. If it does, then multiple rows are written, one
        /// for each entry in `values`. Each list in `values` must have
        /// exactly as many entries as there are entries in
        /// [columns][google.spanner.v1.Mutation.Write.columns] above. Sending
        /// multiple lists is equivalent to sending multiple `Mutation`s, each
        /// containing one `values` entry and repeating
        /// [table][google.spanner.v1.Mutation.Write.table] and
        /// [columns][google.spanner.v1.Mutation.Write.columns]. Individual values in
        /// each list are encoded as described [here][google.spanner.v1.TypeCode].
        ///
        /// [google.spanner.v1.Mutation.Write.columns]: crate::model::mutation::Write::columns
        /// [google.spanner.v1.Mutation.Write.table]: crate::model::mutation::Write::table
        /// [google.spanner.v1.TypeCode]: crate::model::TypeCode
        pub values: std::vec::Vec<wkt::ListValue>,

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

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

        /// Sets the value of [table][crate::model::mutation::Write::table].
        pub fn set_table<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.table = v.into();
            self
        }

        /// Sets the value of [columns][crate::model::mutation::Write::columns].
        pub fn set_columns<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<std::string::String>,
        {
            use std::iter::Iterator;
            self.columns = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [values][crate::model::mutation::Write::values].
        pub fn set_values<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<wkt::ListValue>,
        {
            use std::iter::Iterator;
            self.values = v.into_iter().map(|i| i.into()).collect();
            self
        }
    }

    impl wkt::message::Message for Write {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.Mutation.Write"
        }
    }

    /// Arguments to [delete][google.spanner.v1.Mutation.delete] operations.
    ///
    /// [google.spanner.v1.Mutation.delete]: crate::model::Mutation::operation
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Delete {
        /// Required. The table whose rows will be deleted.
        pub table: std::string::String,

        /// Required. The primary keys of the rows within
        /// [table][google.spanner.v1.Mutation.Delete.table] to delete.  The primary
        /// keys must be specified in the order in which they appear in the `PRIMARY
        /// KEY()` clause of the table's equivalent DDL statement (the DDL statement
        /// used to create the table). Delete is idempotent. The transaction will
        /// succeed even if some or all rows do not exist.
        ///
        /// [google.spanner.v1.Mutation.Delete.table]: crate::model::mutation::Delete::table
        pub key_set: std::option::Option<crate::model::KeySet>,

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

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

        /// Sets the value of [table][crate::model::mutation::Delete::table].
        pub fn set_table<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.table = v.into();
            self
        }

        /// Sets the value of [key_set][crate::model::mutation::Delete::key_set].
        pub fn set_key_set<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::KeySet>,
        {
            self.key_set = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [key_set][crate::model::mutation::Delete::key_set].
        pub fn set_or_clear_key_set<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::KeySet>,
        {
            self.key_set = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for Delete {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.Mutation.Delete"
        }
    }

    /// Arguments to [send][google.spanner.v1.Mutation.send] operations.
    ///
    /// [google.spanner.v1.Mutation.send]: crate::model::Mutation::operation
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Send {
        /// Required. The queue to which the message will be sent.
        pub queue: std::string::String,

        /// Required. The primary key of the message to be sent.
        pub key: std::option::Option<wkt::ListValue>,

        /// The time at which Spanner will begin attempting to deliver the message.
        /// If `deliver_time` is not set, Spanner will deliver the message
        /// immediately. If `deliver_time` is in the past, Spanner will replace it
        /// with a value closer to the current time.
        pub deliver_time: std::option::Option<wkt::Timestamp>,

        /// The payload of the message.
        pub payload: std::option::Option<wkt::Value>,

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

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

        /// Sets the value of [queue][crate::model::mutation::Send::queue].
        pub fn set_queue<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.queue = v.into();
            self
        }

        /// Sets the value of [key][crate::model::mutation::Send::key].
        pub fn set_key<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::ListValue>,
        {
            self.key = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [key][crate::model::mutation::Send::key].
        pub fn set_or_clear_key<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::ListValue>,
        {
            self.key = v.map(|x| x.into());
            self
        }

        /// Sets the value of [deliver_time][crate::model::mutation::Send::deliver_time].
        pub fn set_deliver_time<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.deliver_time = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [deliver_time][crate::model::mutation::Send::deliver_time].
        pub fn set_or_clear_deliver_time<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.deliver_time = v.map(|x| x.into());
            self
        }

        /// Sets the value of [payload][crate::model::mutation::Send::payload].
        pub fn set_payload<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Value>,
        {
            self.payload = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [payload][crate::model::mutation::Send::payload].
        pub fn set_or_clear_payload<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Value>,
        {
            self.payload = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for Send {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.Mutation.Send"
        }
    }

    /// Arguments to [ack][google.spanner.v1.Mutation.ack] operations.
    ///
    /// [google.spanner.v1.Mutation.ack]: crate::model::Mutation::operation
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Ack {
        /// Required. The queue where the message to be acked is stored.
        pub queue: std::string::String,

        /// Required. The primary key of the message to be acked.
        pub key: std::option::Option<wkt::ListValue>,

        /// By default, an attempt to ack a message that does not exist will fail
        /// with a `NOT_FOUND` error. With `ignore_not_found` set to true, the ack
        /// will succeed even if the message does not exist. This is useful for
        /// unconditionally acking a message, even if it is missing or has already
        /// been acked.
        pub ignore_not_found: bool,

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

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

        /// Sets the value of [queue][crate::model::mutation::Ack::queue].
        pub fn set_queue<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.queue = v.into();
            self
        }

        /// Sets the value of [key][crate::model::mutation::Ack::key].
        pub fn set_key<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::ListValue>,
        {
            self.key = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [key][crate::model::mutation::Ack::key].
        pub fn set_or_clear_key<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::ListValue>,
        {
            self.key = v.map(|x| x.into());
            self
        }

        /// Sets the value of [ignore_not_found][crate::model::mutation::Ack::ignore_not_found].
        pub fn set_ignore_not_found<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.ignore_not_found = v.into();
            self
        }
    }

    impl wkt::message::Message for Ack {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.Mutation.Ack"
        }
    }

    /// Required. The operation to perform.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Operation {
        /// Insert new rows in a table. If any of the rows already exist,
        /// the write or transaction fails with error `ALREADY_EXISTS`.
        Insert(std::boxed::Box<crate::model::mutation::Write>),
        /// Update existing rows in a table. If any of the rows does not
        /// already exist, the transaction fails with error `NOT_FOUND`.
        Update(std::boxed::Box<crate::model::mutation::Write>),
        /// Like [insert][google.spanner.v1.Mutation.insert], except that if the row
        /// already exists, then its column values are overwritten with the ones
        /// provided. Any column values not explicitly written are preserved.
        ///
        /// When using
        /// [insert_or_update][google.spanner.v1.Mutation.insert_or_update], just as
        /// when using [insert][google.spanner.v1.Mutation.insert], all `NOT NULL`
        /// columns in the table must be given a value. This holds true even when the
        /// row already exists and will therefore actually be updated.
        ///
        /// [google.spanner.v1.Mutation.insert]: crate::model::Mutation::operation
        /// [google.spanner.v1.Mutation.insert_or_update]: crate::model::Mutation::operation
        InsertOrUpdate(std::boxed::Box<crate::model::mutation::Write>),
        /// Like [insert][google.spanner.v1.Mutation.insert], except that if the row
        /// already exists, it is deleted, and the column values provided are
        /// inserted instead. Unlike
        /// [insert_or_update][google.spanner.v1.Mutation.insert_or_update], this
        /// means any values not explicitly written become `NULL`.
        ///
        /// In an interleaved table, if you create the child table with the
        /// `ON DELETE CASCADE` annotation, then replacing a parent row
        /// also deletes the child rows. Otherwise, you must delete the
        /// child rows before you replace the parent row.
        ///
        /// [google.spanner.v1.Mutation.insert]: crate::model::Mutation::operation
        /// [google.spanner.v1.Mutation.insert_or_update]: crate::model::Mutation::operation
        Replace(std::boxed::Box<crate::model::mutation::Write>),
        /// Delete rows from a table. Succeeds whether or not the named
        /// rows were present.
        Delete(std::boxed::Box<crate::model::mutation::Delete>),
        /// Send a message to a queue.
        Send(std::boxed::Box<crate::model::mutation::Send>),
        /// Ack a message from a queue.
        Ack(std::boxed::Box<crate::model::mutation::Ack>),
    }

    impl Operation {
        /// Initializes the enum to the [Insert](Self::Insert) branch.
        pub fn from_insert(
            value: impl std::convert::Into<std::boxed::Box<crate::model::mutation::Write>>,
        ) -> Self {
            Self::Insert(value.into())
        }
        /// Initializes the enum to the [Update](Self::Update) branch.
        pub fn from_update(
            value: impl std::convert::Into<std::boxed::Box<crate::model::mutation::Write>>,
        ) -> Self {
            Self::Update(value.into())
        }
        /// Initializes the enum to the [InsertOrUpdate](Self::InsertOrUpdate) branch.
        pub fn from_insert_or_update(
            value: impl std::convert::Into<std::boxed::Box<crate::model::mutation::Write>>,
        ) -> Self {
            Self::InsertOrUpdate(value.into())
        }
        /// Initializes the enum to the [Replace](Self::Replace) branch.
        pub fn from_replace(
            value: impl std::convert::Into<std::boxed::Box<crate::model::mutation::Write>>,
        ) -> Self {
            Self::Replace(value.into())
        }
        /// Initializes the enum to the [Delete](Self::Delete) branch.
        pub fn from_delete(
            value: impl std::convert::Into<std::boxed::Box<crate::model::mutation::Delete>>,
        ) -> Self {
            Self::Delete(value.into())
        }
        /// Initializes the enum to the [Send](Self::Send) branch.
        pub fn from_send(
            value: impl std::convert::Into<std::boxed::Box<crate::model::mutation::Send>>,
        ) -> Self {
            Self::Send(value.into())
        }
        /// Initializes the enum to the [Ack](Self::Ack) branch.
        pub fn from_ack(
            value: impl std::convert::Into<std::boxed::Box<crate::model::mutation::Ack>>,
        ) -> Self {
            Self::Ack(value.into())
        }
    }
}

/// Node information for nodes appearing in a
/// [QueryPlan.plan_nodes][google.spanner.v1.QueryPlan.plan_nodes].
///
/// [google.spanner.v1.QueryPlan.plan_nodes]: crate::model::QueryPlan::plan_nodes
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PlanNode {
    /// The `PlanNode`'s index in [node
    /// list][google.spanner.v1.QueryPlan.plan_nodes].
    ///
    /// [google.spanner.v1.QueryPlan.plan_nodes]: crate::model::QueryPlan::plan_nodes
    pub index: i32,

    /// Used to determine the type of node. May be needed for visualizing
    /// different kinds of nodes differently. For example, If the node is a
    /// [SCALAR][google.spanner.v1.PlanNode.Kind.SCALAR] node, it will have a
    /// condensed representation which can be used to directly embed a description
    /// of the node in its parent.
    ///
    /// [google.spanner.v1.PlanNode.Kind.SCALAR]: crate::model::plan_node::Kind::Scalar
    pub kind: crate::model::plan_node::Kind,

    /// The display name for the node.
    pub display_name: std::string::String,

    /// List of child node `index`es and their relationship to this parent.
    pub child_links: std::vec::Vec<crate::model::plan_node::ChildLink>,

    /// Condensed representation for
    /// [SCALAR][google.spanner.v1.PlanNode.Kind.SCALAR] nodes.
    ///
    /// [google.spanner.v1.PlanNode.Kind.SCALAR]: crate::model::plan_node::Kind::Scalar
    pub short_representation: std::option::Option<crate::model::plan_node::ShortRepresentation>,

    /// Attributes relevant to the node contained in a group of key-value pairs.
    /// For example, a Parameter Reference node could have the following
    /// information in its metadata:
    ///
    /// ```norust
    /// {
    ///   "parameter_reference": "param1",
    ///   "parameter_type": "array"
    /// }
    /// ```
    pub metadata: std::option::Option<wkt::Struct>,

    /// The execution statistics associated with the node, contained in a group of
    /// key-value pairs. Only present if the plan was returned as a result of a
    /// profile query. For example, number of executions, number of rows/time per
    /// execution etc.
    pub execution_stats: std::option::Option<wkt::Struct>,

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

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

    /// Sets the value of [index][crate::model::PlanNode::index].
    pub fn set_index<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.index = v.into();
        self
    }

    /// Sets the value of [kind][crate::model::PlanNode::kind].
    pub fn set_kind<T: std::convert::Into<crate::model::plan_node::Kind>>(mut self, v: T) -> Self {
        self.kind = v.into();
        self
    }

    /// Sets the value of [display_name][crate::model::PlanNode::display_name].
    pub fn set_display_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.display_name = v.into();
        self
    }

    /// Sets the value of [child_links][crate::model::PlanNode::child_links].
    pub fn set_child_links<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::plan_node::ChildLink>,
    {
        use std::iter::Iterator;
        self.child_links = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [short_representation][crate::model::PlanNode::short_representation].
    pub fn set_short_representation<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::plan_node::ShortRepresentation>,
    {
        self.short_representation = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [short_representation][crate::model::PlanNode::short_representation].
    pub fn set_or_clear_short_representation<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::plan_node::ShortRepresentation>,
    {
        self.short_representation = v.map(|x| x.into());
        self
    }

    /// Sets the value of [metadata][crate::model::PlanNode::metadata].
    pub fn set_metadata<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.metadata = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [metadata][crate::model::PlanNode::metadata].
    pub fn set_or_clear_metadata<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.metadata = v.map(|x| x.into());
        self
    }

    /// Sets the value of [execution_stats][crate::model::PlanNode::execution_stats].
    pub fn set_execution_stats<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.execution_stats = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [execution_stats][crate::model::PlanNode::execution_stats].
    pub fn set_or_clear_execution_stats<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.execution_stats = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for PlanNode {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.PlanNode"
    }
}

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

    /// Metadata associated with a parent-child relationship appearing in a
    /// [PlanNode][google.spanner.v1.PlanNode].
    ///
    /// [google.spanner.v1.PlanNode]: crate::model::PlanNode
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ChildLink {
        /// The node to which the link points.
        pub child_index: i32,

        /// The type of the link. For example, in Hash Joins this could be used to
        /// distinguish between the build child and the probe child, or in the case
        /// of the child being an output variable, to represent the tag associated
        /// with the output variable.
        pub r#type: std::string::String,

        /// Only present if the child node is
        /// [SCALAR][google.spanner.v1.PlanNode.Kind.SCALAR] and corresponds to an
        /// output variable of the parent node. The field carries the name of the
        /// output variable. For example, a `TableScan` operator that reads rows from
        /// a table will have child links to the `SCALAR` nodes representing the
        /// output variables created for each column that is read by the operator.
        /// The corresponding `variable` fields will be set to the variable names
        /// assigned to the columns.
        ///
        /// [google.spanner.v1.PlanNode.Kind.SCALAR]: crate::model::plan_node::Kind::Scalar
        pub variable: std::string::String,

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

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

        /// Sets the value of [child_index][crate::model::plan_node::ChildLink::child_index].
        pub fn set_child_index<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.child_index = v.into();
            self
        }

        /// Sets the value of [r#type][crate::model::plan_node::ChildLink::type].
        pub fn set_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.r#type = v.into();
            self
        }

        /// Sets the value of [variable][crate::model::plan_node::ChildLink::variable].
        pub fn set_variable<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.variable = v.into();
            self
        }
    }

    impl wkt::message::Message for ChildLink {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.PlanNode.ChildLink"
        }
    }

    /// Condensed representation of a node and its subtree. Only present for
    /// `SCALAR` [PlanNode(s)][google.spanner.v1.PlanNode].
    ///
    /// [google.spanner.v1.PlanNode]: crate::model::PlanNode
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ShortRepresentation {
        /// A string representation of the expression subtree rooted at this node.
        pub description: std::string::String,

        /// A mapping of (subquery variable name) -> (subquery node id) for cases
        /// where the `description` string of this node references a `SCALAR`
        /// subquery contained in the expression subtree rooted at this node. The
        /// referenced `SCALAR` subquery may not necessarily be a direct child of
        /// this node.
        pub subqueries: std::collections::HashMap<std::string::String, i32>,

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

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

        /// Sets the value of [description][crate::model::plan_node::ShortRepresentation::description].
        pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.description = v.into();
            self
        }

        /// Sets the value of [subqueries][crate::model::plan_node::ShortRepresentation::subqueries].
        pub fn set_subqueries<T, K, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = (K, V)>,
            K: std::convert::Into<std::string::String>,
            V: std::convert::Into<i32>,
        {
            use std::iter::Iterator;
            self.subqueries = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
            self
        }
    }

    impl wkt::message::Message for ShortRepresentation {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.PlanNode.ShortRepresentation"
        }
    }

    /// The kind of [PlanNode][google.spanner.v1.PlanNode]. Distinguishes between
    /// the two different kinds of nodes that can appear in a query plan.
    ///
    /// [google.spanner.v1.PlanNode]: crate::model::PlanNode
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Kind {
        /// Not specified.
        Unspecified,
        /// Denotes a Relational operator node in the expression tree. Relational
        /// operators represent iterative processing of rows during query execution.
        /// For example, a `TableScan` operation that reads rows from a table.
        Relational,
        /// Denotes a Scalar node in the expression tree. Scalar nodes represent
        /// non-iterable entities in the query plan. For example, constants or
        /// arithmetic operators appearing inside predicate expressions or references
        /// to column names.
        Scalar,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Kind::value] or
        /// [Kind::name].
        UnknownValue(kind::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for Kind {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Relational,
                2 => Self::Scalar,
                _ => Self::UnknownValue(kind::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Kind {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "KIND_UNSPECIFIED" => Self::Unspecified,
                "RELATIONAL" => Self::Relational,
                "SCALAR" => Self::Scalar,
                _ => Self::UnknownValue(kind::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// Output of query advisor analysis.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct QueryAdvisorResult {
    /// Optional. Index Recommendation for a query. This is an optional field and
    /// the recommendation will only be available when the recommendation
    /// guarantees significant improvement in query performance.
    pub index_advice: std::vec::Vec<crate::model::query_advisor_result::IndexAdvice>,

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

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

    /// Sets the value of [index_advice][crate::model::QueryAdvisorResult::index_advice].
    pub fn set_index_advice<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::query_advisor_result::IndexAdvice>,
    {
        use std::iter::Iterator;
        self.index_advice = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for QueryAdvisorResult {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.QueryAdvisorResult"
    }
}

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

    /// Recommendation to add new indexes to run queries more efficiently.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct IndexAdvice {
        /// Optional. DDL statements to add new indexes that will improve the query.
        pub ddl: std::vec::Vec<std::string::String>,

        /// Optional. Estimated latency improvement factor. For example if the query
        /// currently takes 500 ms to run and the estimated latency with new indexes
        /// is 100 ms this field will be 5.
        pub improvement_factor: f64,

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

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

        /// Sets the value of [ddl][crate::model::query_advisor_result::IndexAdvice::ddl].
        pub fn set_ddl<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<std::string::String>,
        {
            use std::iter::Iterator;
            self.ddl = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [improvement_factor][crate::model::query_advisor_result::IndexAdvice::improvement_factor].
        pub fn set_improvement_factor<T: std::convert::Into<f64>>(mut self, v: T) -> Self {
            self.improvement_factor = v.into();
            self
        }
    }

    impl wkt::message::Message for IndexAdvice {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.QueryAdvisorResult.IndexAdvice"
        }
    }
}

/// Contains an ordered list of nodes appearing in the query plan.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct QueryPlan {
    /// The nodes in the query plan. Plan nodes are returned in pre-order starting
    /// with the plan root. Each [PlanNode][google.spanner.v1.PlanNode]'s `id`
    /// corresponds to its index in `plan_nodes`.
    ///
    /// [google.spanner.v1.PlanNode]: crate::model::PlanNode
    pub plan_nodes: std::vec::Vec<crate::model::PlanNode>,

    /// Optional. The advise/recommendations for a query. Currently this field will
    /// be serving index recommendations for a query.
    pub query_advice: std::option::Option<crate::model::QueryAdvisorResult>,

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

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

    /// Sets the value of [plan_nodes][crate::model::QueryPlan::plan_nodes].
    pub fn set_plan_nodes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::PlanNode>,
    {
        use std::iter::Iterator;
        self.plan_nodes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [query_advice][crate::model::QueryPlan::query_advice].
    pub fn set_query_advice<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::QueryAdvisorResult>,
    {
        self.query_advice = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [query_advice][crate::model::QueryPlan::query_advice].
    pub fn set_or_clear_query_advice<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::QueryAdvisorResult>,
    {
        self.query_advice = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for QueryPlan {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.QueryPlan"
    }
}

/// Results from [Read][google.spanner.v1.Spanner.Read] or
/// [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql].
///
/// [google.spanner.v1.Spanner.ExecuteSql]: crate::client::Spanner::execute_sql
/// [google.spanner.v1.Spanner.Read]: crate::client::Spanner::read
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ResultSet {
    /// Metadata about the result set, such as row type information.
    pub metadata: std::option::Option<crate::model::ResultSetMetadata>,

    /// Each element in `rows` is a row whose format is defined by
    /// [metadata.row_type][google.spanner.v1.ResultSetMetadata.row_type]. The ith
    /// element in each row matches the ith field in
    /// [metadata.row_type][google.spanner.v1.ResultSetMetadata.row_type]. Elements
    /// are encoded based on type as described [here][google.spanner.v1.TypeCode].
    ///
    /// [google.spanner.v1.ResultSetMetadata.row_type]: crate::model::ResultSetMetadata::row_type
    /// [google.spanner.v1.TypeCode]: crate::model::TypeCode
    pub rows: std::vec::Vec<wkt::ListValue>,

    /// Query plan and execution statistics for the SQL statement that
    /// produced this result set. These can be requested by setting
    /// [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode].
    /// DML statements always produce stats containing the number of rows
    /// modified, unless executed using the
    /// [ExecuteSqlRequest.QueryMode.PLAN][google.spanner.v1.ExecuteSqlRequest.QueryMode.PLAN]
    /// [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode].
    /// Other fields might or might not be populated, based on the
    /// [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode].
    ///
    /// [google.spanner.v1.ExecuteSqlRequest.QueryMode.PLAN]: crate::model::execute_sql_request::QueryMode::Plan
    /// [google.spanner.v1.ExecuteSqlRequest.query_mode]: crate::model::ExecuteSqlRequest::query_mode
    pub stats: std::option::Option<crate::model::ResultSetStats>,

    /// Optional. A precommit token is included if the read-write transaction is on
    /// a multiplexed session. Pass the precommit token with the highest sequence
    /// number from this transaction attempt to the
    /// [Commit][google.spanner.v1.Spanner.Commit] request for this transaction.
    ///
    /// [google.spanner.v1.Spanner.Commit]: crate::client::Spanner::commit
    pub precommit_token: std::option::Option<crate::model::MultiplexedSessionPrecommitToken>,

    /// Optional. A cache update expresses a set of changes the client should
    /// incorporate into its location cache. The client should discard the changes
    /// if they are older than the data it already has. This data can be obtained
    /// in response to requests that included a `RoutingHint` field, but may also
    /// be obtained by explicit location-fetching RPCs which may be added in the
    /// future.
    pub cache_update: std::option::Option<crate::model::CacheUpdate>,

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

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

    /// Sets the value of [metadata][crate::model::ResultSet::metadata].
    pub fn set_metadata<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ResultSetMetadata>,
    {
        self.metadata = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [metadata][crate::model::ResultSet::metadata].
    pub fn set_or_clear_metadata<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ResultSetMetadata>,
    {
        self.metadata = v.map(|x| x.into());
        self
    }

    /// Sets the value of [rows][crate::model::ResultSet::rows].
    pub fn set_rows<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<wkt::ListValue>,
    {
        use std::iter::Iterator;
        self.rows = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [stats][crate::model::ResultSet::stats].
    pub fn set_stats<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ResultSetStats>,
    {
        self.stats = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [stats][crate::model::ResultSet::stats].
    pub fn set_or_clear_stats<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ResultSetStats>,
    {
        self.stats = v.map(|x| x.into());
        self
    }

    /// Sets the value of [precommit_token][crate::model::ResultSet::precommit_token].
    pub fn set_precommit_token<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MultiplexedSessionPrecommitToken>,
    {
        self.precommit_token = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [precommit_token][crate::model::ResultSet::precommit_token].
    pub fn set_or_clear_precommit_token<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MultiplexedSessionPrecommitToken>,
    {
        self.precommit_token = v.map(|x| x.into());
        self
    }

    /// Sets the value of [cache_update][crate::model::ResultSet::cache_update].
    pub fn set_cache_update<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::CacheUpdate>,
    {
        self.cache_update = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [cache_update][crate::model::ResultSet::cache_update].
    pub fn set_or_clear_cache_update<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::CacheUpdate>,
    {
        self.cache_update = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ResultSet {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.ResultSet"
    }
}

/// Partial results from a streaming read or SQL query. Streaming reads and
/// SQL queries better tolerate large result sets, large rows, and large
/// values, but are a little trickier to consume.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PartialResultSet {
    /// Metadata about the result set, such as row type information.
    /// Only present in the first response.
    pub metadata: std::option::Option<crate::model::ResultSetMetadata>,

    /// A streamed result set consists of a stream of values, which might
    /// be split into many `PartialResultSet` messages to accommodate
    /// large rows and/or large values. Every N complete values defines a
    /// row, where N is equal to the number of entries in
    /// [metadata.row_type.fields][google.spanner.v1.StructType.fields].
    ///
    /// Most values are encoded based on type as described
    /// [here][google.spanner.v1.TypeCode].
    ///
    /// It's possible that the last value in values is "chunked",
    /// meaning that the rest of the value is sent in subsequent
    /// `PartialResultSet`(s). This is denoted by the
    /// [chunked_value][google.spanner.v1.PartialResultSet.chunked_value] field.
    /// Two or more chunked values can be merged to form a complete value as
    /// follows:
    ///
    /// * `bool/number/null`: can't be chunked
    /// * `string`: concatenate the strings
    /// * `list`: concatenate the lists. If the last element in a list is a
    ///   `string`, `list`, or `object`, merge it with the first element in
    ///   the next list by applying these rules recursively.
    /// * `object`: concatenate the (field name, field value) pairs. If a
    ///   field name is duplicated, then apply these rules recursively
    ///   to merge the field values.
    ///
    /// Some examples of merging:
    ///
    /// ```norust
    /// Strings are concatenated.
    /// "foo", "bar" => "foobar"
    ///
    /// Lists of non-strings are concatenated.
    /// [2, 3], [4] => [2, 3, 4]
    ///
    /// Lists are concatenated, but the last and first elements are merged
    /// because they are strings.
    /// ["a", "b"], ["c", "d"] => ["a", "bc", "d"]
    ///
    /// Lists are concatenated, but the last and first elements are merged
    /// because they are lists. Recursively, the last and first elements
    /// of the inner lists are merged because they are strings.
    /// ["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
    ///
    /// Non-overlapping object fields are combined.
    /// {"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
    ///
    /// Overlapping object fields are merged.
    /// {"a": "1"}, {"a": "2"} => {"a": "12"}
    ///
    /// Examples of merging objects containing lists of strings.
    /// {"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
    /// ```
    ///
    /// For a more complete example, suppose a streaming SQL query is
    /// yielding a result set whose rows contain a single string
    /// field. The following `PartialResultSet`s might be yielded:
    ///
    /// ```norust
    /// {
    ///   "metadata": { ... }
    ///   "values": ["Hello", "W"]
    ///   "chunked_value": true
    ///   "resume_token": "Af65..."
    /// }
    /// {
    ///   "values": ["orl"]
    ///   "chunked_value": true
    /// }
    /// {
    ///   "values": ["d"]
    ///   "resume_token": "Zx1B..."
    /// }
    /// ```
    ///
    /// This sequence of `PartialResultSet`s encodes two rows, one
    /// containing the field value `"Hello"`, and a second containing the
    /// field value `"World" = "W" + "orl" + "d"`.
    ///
    /// Not all `PartialResultSet`s contain a `resume_token`. Execution can only be
    /// resumed from a previously yielded `resume_token`. For the above sequence of
    /// `PartialResultSet`s, resuming the query with `"resume_token": "Af65..."`
    /// yields results from the `PartialResultSet` with value "orl".
    ///
    /// [google.spanner.v1.PartialResultSet.chunked_value]: crate::model::PartialResultSet::chunked_value
    /// [google.spanner.v1.StructType.fields]: crate::model::StructType::fields
    /// [google.spanner.v1.TypeCode]: crate::model::TypeCode
    pub values: std::vec::Vec<wkt::Value>,

    /// If true, then the final value in
    /// [values][google.spanner.v1.PartialResultSet.values] is chunked, and must be
    /// combined with more values from subsequent `PartialResultSet`s to obtain a
    /// complete field value.
    ///
    /// [google.spanner.v1.PartialResultSet.values]: crate::model::PartialResultSet::values
    pub chunked_value: bool,

    /// Streaming calls might be interrupted for a variety of reasons, such
    /// as TCP connection loss. If this occurs, the stream of results can
    /// be resumed by re-sending the original request and including
    /// `resume_token`. Note that executing any other transaction in the
    /// same session invalidates the token.
    pub resume_token: ::bytes::Bytes,

    /// Query plan and execution statistics for the statement that produced this
    /// streaming result set. These can be requested by setting
    /// [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode]
    /// and are sent only once with the last response in the stream. This field is
    /// also present in the last response for DML statements.
    ///
    /// [google.spanner.v1.ExecuteSqlRequest.query_mode]: crate::model::ExecuteSqlRequest::query_mode
    pub stats: std::option::Option<crate::model::ResultSetStats>,

    /// Optional. A precommit token is included if the read-write transaction
    /// has multiplexed sessions enabled. Pass the precommit token with the highest
    /// sequence number from this transaction attempt to the
    /// [Commit][google.spanner.v1.Spanner.Commit] request for this transaction.
    ///
    /// [google.spanner.v1.Spanner.Commit]: crate::client::Spanner::commit
    pub precommit_token: std::option::Option<crate::model::MultiplexedSessionPrecommitToken>,

    /// Optional. Indicates whether this is the last `PartialResultSet` in the
    /// stream. The server might optionally set this field. Clients shouldn't rely
    /// on this field being set in all cases.
    pub last: bool,

    /// Optional. A cache update expresses a set of changes the client should
    /// incorporate into its location cache. The client should discard the changes
    /// if they are older than the data it already has. This data can be obtained
    /// in response to requests that included a `RoutingHint` field, but may also
    /// be obtained by explicit location-fetching RPCs which may be added in the
    /// future.
    pub cache_update: std::option::Option<crate::model::CacheUpdate>,

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

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

    /// Sets the value of [metadata][crate::model::PartialResultSet::metadata].
    pub fn set_metadata<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ResultSetMetadata>,
    {
        self.metadata = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [metadata][crate::model::PartialResultSet::metadata].
    pub fn set_or_clear_metadata<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ResultSetMetadata>,
    {
        self.metadata = v.map(|x| x.into());
        self
    }

    /// Sets the value of [values][crate::model::PartialResultSet::values].
    pub fn set_values<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<wkt::Value>,
    {
        use std::iter::Iterator;
        self.values = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [chunked_value][crate::model::PartialResultSet::chunked_value].
    pub fn set_chunked_value<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.chunked_value = v.into();
        self
    }

    /// Sets the value of [resume_token][crate::model::PartialResultSet::resume_token].
    pub fn set_resume_token<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.resume_token = v.into();
        self
    }

    /// Sets the value of [stats][crate::model::PartialResultSet::stats].
    pub fn set_stats<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ResultSetStats>,
    {
        self.stats = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [stats][crate::model::PartialResultSet::stats].
    pub fn set_or_clear_stats<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ResultSetStats>,
    {
        self.stats = v.map(|x| x.into());
        self
    }

    /// Sets the value of [precommit_token][crate::model::PartialResultSet::precommit_token].
    pub fn set_precommit_token<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MultiplexedSessionPrecommitToken>,
    {
        self.precommit_token = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [precommit_token][crate::model::PartialResultSet::precommit_token].
    pub fn set_or_clear_precommit_token<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MultiplexedSessionPrecommitToken>,
    {
        self.precommit_token = v.map(|x| x.into());
        self
    }

    /// Sets the value of [last][crate::model::PartialResultSet::last].
    pub fn set_last<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.last = v.into();
        self
    }

    /// Sets the value of [cache_update][crate::model::PartialResultSet::cache_update].
    pub fn set_cache_update<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::CacheUpdate>,
    {
        self.cache_update = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [cache_update][crate::model::PartialResultSet::cache_update].
    pub fn set_or_clear_cache_update<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::CacheUpdate>,
    {
        self.cache_update = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for PartialResultSet {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.PartialResultSet"
    }
}

/// Metadata about a [ResultSet][google.spanner.v1.ResultSet] or
/// [PartialResultSet][google.spanner.v1.PartialResultSet].
///
/// [google.spanner.v1.PartialResultSet]: crate::model::PartialResultSet
/// [google.spanner.v1.ResultSet]: crate::model::ResultSet
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ResultSetMetadata {
    /// Indicates the field names and types for the rows in the result
    /// set. For example, a SQL query like `"SELECT UserId, UserName FROM
    /// Users"` could return a `row_type` value like:
    ///
    /// ```norust
    /// "fields": [
    ///   { "name": "UserId", "type": { "code": "INT64" } },
    ///   { "name": "UserName", "type": { "code": "STRING" } },
    /// ]
    /// ```
    pub row_type: std::option::Option<crate::model::StructType>,

    /// If the read or SQL query began a transaction as a side-effect, the
    /// information about the new transaction is yielded here.
    pub transaction: std::option::Option<crate::model::Transaction>,

    /// A SQL query can be parameterized. In PLAN mode, these parameters can be
    /// undeclared. This indicates the field names and types for those undeclared
    /// parameters in the SQL query. For example, a SQL query like `"SELECT * FROM
    /// Users where UserId = @userId and UserName = @userName "` could return a
    /// `undeclared_parameters` value like:
    ///
    /// ```norust
    /// "fields": [
    ///   { "name": "UserId", "type": { "code": "INT64" } },
    ///   { "name": "UserName", "type": { "code": "STRING" } },
    /// ]
    /// ```
    pub undeclared_parameters: std::option::Option<crate::model::StructType>,

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

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

    /// Sets the value of [row_type][crate::model::ResultSetMetadata::row_type].
    pub fn set_row_type<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::StructType>,
    {
        self.row_type = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [row_type][crate::model::ResultSetMetadata::row_type].
    pub fn set_or_clear_row_type<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::StructType>,
    {
        self.row_type = v.map(|x| x.into());
        self
    }

    /// Sets the value of [transaction][crate::model::ResultSetMetadata::transaction].
    pub fn set_transaction<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Transaction>,
    {
        self.transaction = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [transaction][crate::model::ResultSetMetadata::transaction].
    pub fn set_or_clear_transaction<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Transaction>,
    {
        self.transaction = v.map(|x| x.into());
        self
    }

    /// Sets the value of [undeclared_parameters][crate::model::ResultSetMetadata::undeclared_parameters].
    pub fn set_undeclared_parameters<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::StructType>,
    {
        self.undeclared_parameters = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [undeclared_parameters][crate::model::ResultSetMetadata::undeclared_parameters].
    pub fn set_or_clear_undeclared_parameters<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::StructType>,
    {
        self.undeclared_parameters = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ResultSetMetadata {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.ResultSetMetadata"
    }
}

/// Additional statistics about a [ResultSet][google.spanner.v1.ResultSet] or
/// [PartialResultSet][google.spanner.v1.PartialResultSet].
///
/// [google.spanner.v1.PartialResultSet]: crate::model::PartialResultSet
/// [google.spanner.v1.ResultSet]: crate::model::ResultSet
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ResultSetStats {
    /// [QueryPlan][google.spanner.v1.QueryPlan] for the query associated with this
    /// result.
    ///
    /// [google.spanner.v1.QueryPlan]: crate::model::QueryPlan
    pub query_plan: std::option::Option<crate::model::QueryPlan>,

    /// Aggregated statistics from the execution of the query. Only present when
    /// the query is profiled. For example, a query could return the statistics as
    /// follows:
    ///
    /// ```norust
    /// {
    ///   "rows_returned": "3",
    ///   "elapsed_time": "1.22 secs",
    ///   "cpu_time": "1.19 secs"
    /// }
    /// ```
    pub query_stats: std::option::Option<wkt::Struct>,

    /// The number of rows modified by the DML statement.
    pub row_count: std::option::Option<crate::model::result_set_stats::RowCount>,

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

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

    /// Sets the value of [query_plan][crate::model::ResultSetStats::query_plan].
    pub fn set_query_plan<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::QueryPlan>,
    {
        self.query_plan = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [query_plan][crate::model::ResultSetStats::query_plan].
    pub fn set_or_clear_query_plan<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::QueryPlan>,
    {
        self.query_plan = v.map(|x| x.into());
        self
    }

    /// Sets the value of [query_stats][crate::model::ResultSetStats::query_stats].
    pub fn set_query_stats<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.query_stats = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [query_stats][crate::model::ResultSetStats::query_stats].
    pub fn set_or_clear_query_stats<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.query_stats = v.map(|x| x.into());
        self
    }

    /// Sets the value of [row_count][crate::model::ResultSetStats::row_count].
    ///
    /// Note that all the setters affecting `row_count` are mutually
    /// exclusive.
    pub fn set_row_count<
        T: std::convert::Into<std::option::Option<crate::model::result_set_stats::RowCount>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.row_count = v.into();
        self
    }

    /// The value of [row_count][crate::model::ResultSetStats::row_count]
    /// if it holds a `RowCountExact`, `None` if the field is not set or
    /// holds a different branch.
    pub fn row_count_exact(&self) -> std::option::Option<&i64> {
        #[allow(unreachable_patterns)]
        self.row_count.as_ref().and_then(|v| match v {
            crate::model::result_set_stats::RowCount::RowCountExact(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [row_count][crate::model::ResultSetStats::row_count]
    /// to hold a `RowCountExact`.
    ///
    /// Note that all the setters affecting `row_count` are
    /// mutually exclusive.
    pub fn set_row_count_exact<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.row_count = std::option::Option::Some(
            crate::model::result_set_stats::RowCount::RowCountExact(v.into()),
        );
        self
    }

    /// The value of [row_count][crate::model::ResultSetStats::row_count]
    /// if it holds a `RowCountLowerBound`, `None` if the field is not set or
    /// holds a different branch.
    pub fn row_count_lower_bound(&self) -> std::option::Option<&i64> {
        #[allow(unreachable_patterns)]
        self.row_count.as_ref().and_then(|v| match v {
            crate::model::result_set_stats::RowCount::RowCountLowerBound(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [row_count][crate::model::ResultSetStats::row_count]
    /// to hold a `RowCountLowerBound`.
    ///
    /// Note that all the setters affecting `row_count` are
    /// mutually exclusive.
    pub fn set_row_count_lower_bound<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.row_count = std::option::Option::Some(
            crate::model::result_set_stats::RowCount::RowCountLowerBound(v.into()),
        );
        self
    }
}

impl wkt::message::Message for ResultSetStats {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.ResultSetStats"
    }
}

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

    /// The number of rows modified by the DML statement.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum RowCount {
        /// Standard DML returns an exact count of rows that were modified.
        RowCountExact(i64),
        /// Partitioned DML doesn't offer exactly-once semantics, so it
        /// returns a lower bound of the rows modified.
        RowCountLowerBound(i64),
    }

    impl RowCount {
        /// Initializes the enum to the [RowCountExact](Self::RowCountExact) branch.
        pub fn from_row_count_exact(value: impl std::convert::Into<i64>) -> Self {
            Self::RowCountExact(value.into())
        }
        /// Initializes the enum to the [RowCountLowerBound](Self::RowCountLowerBound) branch.
        pub fn from_row_count_lower_bound(value: impl std::convert::Into<i64>) -> Self {
            Self::RowCountLowerBound(value.into())
        }
    }
}

/// The request for [CreateSession][google.spanner.v1.Spanner.CreateSession].
///
/// [google.spanner.v1.Spanner.CreateSession]: crate::client::Spanner::create_session
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateSessionRequest {
    /// Required. The database in which the new session is created.
    pub database: std::string::String,

    /// Required. The session to create.
    pub session: std::option::Option<crate::model::Session>,

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

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

    /// Sets the value of [database][crate::model::CreateSessionRequest::database].
    pub fn set_database<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.database = v.into();
        self
    }

    /// Sets the value of [session][crate::model::CreateSessionRequest::session].
    pub fn set_session<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Session>,
    {
        self.session = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [session][crate::model::CreateSessionRequest::session].
    pub fn set_or_clear_session<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Session>,
    {
        self.session = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for CreateSessionRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.CreateSessionRequest"
    }
}

/// The request for
/// [BatchCreateSessions][google.spanner.v1.Spanner.BatchCreateSessions].
///
/// [google.spanner.v1.Spanner.BatchCreateSessions]: crate::client::Spanner::batch_create_sessions
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchCreateSessionsRequest {
    /// Required. The database in which the new sessions are created.
    pub database: std::string::String,

    /// Parameters to apply to each created session.
    pub session_template: std::option::Option<crate::model::Session>,

    /// Required. The number of sessions to be created in this batch call. At least
    /// one session is created. The API can return fewer than the requested number
    /// of sessions. If a specific number of sessions are desired, the client can
    /// make additional calls to `BatchCreateSessions` (adjusting
    /// [session_count][google.spanner.v1.BatchCreateSessionsRequest.session_count]
    /// as necessary).
    ///
    /// [google.spanner.v1.BatchCreateSessionsRequest.session_count]: crate::model::BatchCreateSessionsRequest::session_count
    pub session_count: i32,

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

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

    /// Sets the value of [database][crate::model::BatchCreateSessionsRequest::database].
    pub fn set_database<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.database = v.into();
        self
    }

    /// Sets the value of [session_template][crate::model::BatchCreateSessionsRequest::session_template].
    pub fn set_session_template<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Session>,
    {
        self.session_template = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [session_template][crate::model::BatchCreateSessionsRequest::session_template].
    pub fn set_or_clear_session_template<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Session>,
    {
        self.session_template = v.map(|x| x.into());
        self
    }

    /// Sets the value of [session_count][crate::model::BatchCreateSessionsRequest::session_count].
    pub fn set_session_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.session_count = v.into();
        self
    }
}

impl wkt::message::Message for BatchCreateSessionsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.BatchCreateSessionsRequest"
    }
}

/// The response for
/// [BatchCreateSessions][google.spanner.v1.Spanner.BatchCreateSessions].
///
/// [google.spanner.v1.Spanner.BatchCreateSessions]: crate::client::Spanner::batch_create_sessions
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchCreateSessionsResponse {
    /// The freshly created sessions.
    pub session: std::vec::Vec<crate::model::Session>,

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

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

    /// Sets the value of [session][crate::model::BatchCreateSessionsResponse::session].
    pub fn set_session<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Session>,
    {
        use std::iter::Iterator;
        self.session = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for BatchCreateSessionsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.BatchCreateSessionsResponse"
    }
}

/// A session in the Cloud Spanner API.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Session {
    /// Output only. The name of the session. This is always system-assigned.
    pub name: std::string::String,

    /// The labels for the session.
    ///
    /// * Label keys must be between 1 and 63 characters long and must conform to
    ///   the following regular expression: `[a-z]([-a-z0-9]*[a-z0-9])?`.
    /// * Label values must be between 0 and 63 characters long and must conform
    ///   to the regular expression `([a-z]([-a-z0-9]*[a-z0-9])?)?`.
    /// * No more than 64 labels can be associated with a given session.
    ///
    /// See <https://goo.gl/xmQnxf> for more information on and examples of labels.
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. The timestamp when the session is created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The approximate timestamp when the session is last used. It's
    /// typically earlier than the actual last use time.
    pub approximate_last_use_time: std::option::Option<wkt::Timestamp>,

    /// The database role which created this session.
    pub creator_role: std::string::String,

    /// Optional. If `true`, specifies a multiplexed session. Use a multiplexed
    /// session for multiple, concurrent operations including any combination of
    /// read-only and read-write transactions. Use
    /// [`sessions.create`][google.spanner.v1.Spanner.CreateSession] to create
    /// multiplexed sessions. Don't use
    /// [BatchCreateSessions][google.spanner.v1.Spanner.BatchCreateSessions] to
    /// create a multiplexed session. You can't delete or list multiplexed
    /// sessions.
    ///
    /// [google.spanner.v1.Spanner.BatchCreateSessions]: crate::client::Spanner::batch_create_sessions
    /// [google.spanner.v1.Spanner.CreateSession]: crate::client::Spanner::create_session
    pub multiplexed: bool,

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

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

    /// Sets the value of [name][crate::model::Session::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [labels][crate::model::Session::labels].
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [create_time][crate::model::Session::create_time].
    pub fn set_create_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [create_time][crate::model::Session::create_time].
    pub fn set_or_clear_create_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [approximate_last_use_time][crate::model::Session::approximate_last_use_time].
    pub fn set_approximate_last_use_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.approximate_last_use_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [approximate_last_use_time][crate::model::Session::approximate_last_use_time].
    pub fn set_or_clear_approximate_last_use_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.approximate_last_use_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [creator_role][crate::model::Session::creator_role].
    pub fn set_creator_role<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.creator_role = v.into();
        self
    }

    /// Sets the value of [multiplexed][crate::model::Session::multiplexed].
    pub fn set_multiplexed<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.multiplexed = v.into();
        self
    }
}

impl wkt::message::Message for Session {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.Session"
    }
}

/// The request for [GetSession][google.spanner.v1.Spanner.GetSession].
///
/// [google.spanner.v1.Spanner.GetSession]: crate::client::Spanner::get_session
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetSessionRequest {
    /// Required. The name of the session to retrieve.
    pub name: std::string::String,

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

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

    /// Sets the value of [name][crate::model::GetSessionRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetSessionRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.GetSessionRequest"
    }
}

/// The request for [ListSessions][google.spanner.v1.Spanner.ListSessions].
///
/// [google.spanner.v1.Spanner.ListSessions]: crate::client::Spanner::list_sessions
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListSessionsRequest {
    /// Required. The database in which to list sessions.
    pub database: std::string::String,

    /// Number of sessions to be returned in the response. If 0 or less, defaults
    /// to the server's maximum allowed page size.
    pub page_size: i32,

    /// If non-empty, `page_token` should contain a
    /// [next_page_token][google.spanner.v1.ListSessionsResponse.next_page_token]
    /// from a previous
    /// [ListSessionsResponse][google.spanner.v1.ListSessionsResponse].
    ///
    /// [google.spanner.v1.ListSessionsResponse]: crate::model::ListSessionsResponse
    /// [google.spanner.v1.ListSessionsResponse.next_page_token]: crate::model::ListSessionsResponse::next_page_token
    pub page_token: std::string::String,

    /// An expression for filtering the results of the request. Filter rules are
    /// case insensitive. The fields eligible for filtering are:
    ///
    /// * `labels.key` where key is the name of a label
    ///
    /// Some examples of using filters are:
    ///
    /// * `labels.env:*` --> The session has the label "env".
    /// * `labels.env:dev` --> The session has the label "env" and the value of
    ///   the label contains the string "dev".
    pub filter: std::string::String,

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

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

    /// Sets the value of [database][crate::model::ListSessionsRequest::database].
    pub fn set_database<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.database = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListSessionsRequest::page_size].
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListSessionsRequest::page_token].
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::ListSessionsRequest::filter].
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }
}

impl wkt::message::Message for ListSessionsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.ListSessionsRequest"
    }
}

/// The response for [ListSessions][google.spanner.v1.Spanner.ListSessions].
///
/// [google.spanner.v1.Spanner.ListSessions]: crate::client::Spanner::list_sessions
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListSessionsResponse {
    /// The list of requested sessions.
    pub sessions: std::vec::Vec<crate::model::Session>,

    /// `next_page_token` can be sent in a subsequent
    /// [ListSessions][google.spanner.v1.Spanner.ListSessions] call to fetch more
    /// of the matching sessions.
    ///
    /// [google.spanner.v1.Spanner.ListSessions]: crate::client::Spanner::list_sessions
    pub next_page_token: std::string::String,

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

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

    /// Sets the value of [sessions][crate::model::ListSessionsResponse::sessions].
    pub fn set_sessions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Session>,
    {
        use std::iter::Iterator;
        self.sessions = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [next_page_token][crate::model::ListSessionsResponse::next_page_token].
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }
}

impl wkt::message::Message for ListSessionsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.ListSessionsResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListSessionsResponse {
    type PageItem = crate::model::Session;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.sessions
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// The request for [DeleteSession][google.spanner.v1.Spanner.DeleteSession].
///
/// [google.spanner.v1.Spanner.DeleteSession]: crate::client::Spanner::delete_session
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteSessionRequest {
    /// Required. The name of the session to delete.
    pub name: std::string::String,

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

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

    /// Sets the value of [name][crate::model::DeleteSessionRequest::name].
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for DeleteSessionRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.DeleteSessionRequest"
    }
}

/// Common request options for various APIs.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RequestOptions {
    /// Priority for the request.
    pub priority: crate::model::request_options::Priority,

    /// A per-request tag which can be applied to queries or reads, used for
    /// statistics collection.
    /// Both `request_tag` and `transaction_tag` can be specified for a read or
    /// query that belongs to a transaction.
    /// This field is ignored for requests where it's not applicable (for example,
    /// `CommitRequest`).
    /// Legal characters for `request_tag` values are all printable characters
    /// (ASCII 32 - 126) and the length of a request_tag is limited to 50
    /// characters. Values that exceed this limit are truncated.
    /// Any leading underscore (_) characters are removed from the string.
    pub request_tag: std::string::String,

    /// A tag used for statistics collection about this transaction.
    /// Both `request_tag` and `transaction_tag` can be specified for a read or
    /// query that belongs to a transaction.
    /// To enable tagging on a transaction, `transaction_tag` must be set to the
    /// same value for all requests belonging to the same transaction, including
    /// [BeginTransaction][google.spanner.v1.Spanner.BeginTransaction].
    /// If this request doesn't belong to any transaction, `transaction_tag` is
    /// ignored.
    /// Legal characters for `transaction_tag` values are all printable characters
    /// (ASCII 32 - 126) and the length of a `transaction_tag` is limited to 50
    /// characters. Values that exceed this limit are truncated.
    /// Any leading underscore (_) characters are removed from the string.
    ///
    /// [google.spanner.v1.Spanner.BeginTransaction]: crate::client::Spanner::begin_transaction
    pub transaction_tag: std::string::String,

    /// Optional. Optional context that may be needed for some requests.
    pub client_context: std::option::Option<crate::model::request_options::ClientContext>,

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

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

    /// Sets the value of [priority][crate::model::RequestOptions::priority].
    pub fn set_priority<T: std::convert::Into<crate::model::request_options::Priority>>(
        mut self,
        v: T,
    ) -> Self {
        self.priority = v.into();
        self
    }

    /// Sets the value of [request_tag][crate::model::RequestOptions::request_tag].
    pub fn set_request_tag<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_tag = v.into();
        self
    }

    /// Sets the value of [transaction_tag][crate::model::RequestOptions::transaction_tag].
    pub fn set_transaction_tag<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.transaction_tag = v.into();
        self
    }

    /// Sets the value of [client_context][crate::model::RequestOptions::client_context].
    pub fn set_client_context<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::request_options::ClientContext>,
    {
        self.client_context = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [client_context][crate::model::RequestOptions::client_context].
    pub fn set_or_clear_client_context<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::request_options::ClientContext>,
    {
        self.client_context = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for RequestOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.RequestOptions"
    }
}

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

    /// Container for various pieces of client-owned context attached to a request.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ClientContext {
        /// Optional. Map of parameter name to value for this request. These values
        /// will be returned by any SECURE_CONTEXT() calls invoked by this request
        /// (e.g., by queries against Parameterized Secure Views).
        pub secure_context: std::collections::HashMap<std::string::String, wkt::Value>,

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

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

        /// Sets the value of [secure_context][crate::model::request_options::ClientContext::secure_context].
        pub fn set_secure_context<T, K, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = (K, V)>,
            K: std::convert::Into<std::string::String>,
            V: std::convert::Into<wkt::Value>,
        {
            use std::iter::Iterator;
            self.secure_context = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
            self
        }
    }

    impl wkt::message::Message for ClientContext {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.RequestOptions.ClientContext"
        }
    }

    /// The relative priority for requests. Note that priority isn't applicable
    /// for [BeginTransaction][google.spanner.v1.Spanner.BeginTransaction].
    ///
    /// The priority acts as a hint to the Cloud Spanner scheduler and doesn't
    /// guarantee priority or order of execution. For example:
    ///
    /// * Some parts of a write operation always execute at `PRIORITY_HIGH`,
    ///   regardless of the specified priority. This can cause you to see an
    ///   increase in high priority workload even when executing a low priority
    ///   request. This can also potentially cause a priority inversion where a
    ///   lower priority request is fulfilled ahead of a higher priority
    ///   request.
    /// * If a transaction contains multiple operations with different priorities,
    ///   Cloud Spanner doesn't guarantee to process the higher priority
    ///   operations first. There might be other constraints to satisfy, such as
    ///   the order of operations.
    ///
    /// [google.spanner.v1.Spanner.BeginTransaction]: crate::client::Spanner::begin_transaction
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Priority {
        /// `PRIORITY_UNSPECIFIED` is equivalent to `PRIORITY_HIGH`.
        Unspecified,
        /// This specifies that the request is low priority.
        Low,
        /// This specifies that the request is medium priority.
        Medium,
        /// This specifies that the request is high priority.
        High,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Priority::value] or
        /// [Priority::name].
        UnknownValue(priority::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for Priority {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Low,
                2 => Self::Medium,
                3 => Self::High,
                _ => Self::UnknownValue(priority::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Priority {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "PRIORITY_UNSPECIFIED" => Self::Unspecified,
                "PRIORITY_LOW" => Self::Low,
                "PRIORITY_MEDIUM" => Self::Medium,
                "PRIORITY_HIGH" => Self::High,
                _ => Self::UnknownValue(priority::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// The `DirectedReadOptions` can be used to indicate which replicas or regions
/// should be used for non-transactional reads or queries.
///
/// `DirectedReadOptions` can only be specified for a read-only transaction,
/// otherwise the API returns an `INVALID_ARGUMENT` error.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DirectedReadOptions {
    /// Required. At most one of either `include_replicas` or `exclude_replicas`
    /// should be present in the message.
    pub replicas: std::option::Option<crate::model::directed_read_options::Replicas>,

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

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

    /// Sets the value of [replicas][crate::model::DirectedReadOptions::replicas].
    ///
    /// Note that all the setters affecting `replicas` are mutually
    /// exclusive.
    pub fn set_replicas<
        T: std::convert::Into<std::option::Option<crate::model::directed_read_options::Replicas>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.replicas = v.into();
        self
    }

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

    /// Sets the value of [replicas][crate::model::DirectedReadOptions::replicas]
    /// to hold a `IncludeReplicas`.
    ///
    /// Note that all the setters affecting `replicas` are
    /// mutually exclusive.
    pub fn set_include_replicas<
        T: std::convert::Into<std::boxed::Box<crate::model::directed_read_options::IncludeReplicas>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.replicas = std::option::Option::Some(
            crate::model::directed_read_options::Replicas::IncludeReplicas(v.into()),
        );
        self
    }

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

    /// Sets the value of [replicas][crate::model::DirectedReadOptions::replicas]
    /// to hold a `ExcludeReplicas`.
    ///
    /// Note that all the setters affecting `replicas` are
    /// mutually exclusive.
    pub fn set_exclude_replicas<
        T: std::convert::Into<std::boxed::Box<crate::model::directed_read_options::ExcludeReplicas>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.replicas = std::option::Option::Some(
            crate::model::directed_read_options::Replicas::ExcludeReplicas(v.into()),
        );
        self
    }
}

impl wkt::message::Message for DirectedReadOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.DirectedReadOptions"
    }
}

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

    /// The directed read replica selector.
    /// Callers must provide one or more of the following fields for replica
    /// selection:
    ///
    /// * `location` - The location must be one of the regions within the
    ///   multi-region configuration of your database.
    /// * `type` - The type of the replica.
    ///
    /// Some examples of using replica_selectors are:
    ///
    /// * `location:us-east1` --> The "us-east1" replica(s) of any available type
    ///   is used to process the request.
    /// * `type:READ_ONLY`    --> The "READ_ONLY" type replica(s) in the nearest
    ///   available location are used to process the
    ///   request.
    /// * `location:us-east1 type:READ_ONLY` --> The "READ_ONLY" type replica(s)
    ///   in location "us-east1" is used to process
    ///   the request.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ReplicaSelection {
        /// The location or region of the serving requests, for example, "us-east1".
        pub location: std::string::String,

        /// The type of replica.
        pub r#type: crate::model::directed_read_options::replica_selection::Type,

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

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

        /// Sets the value of [location][crate::model::directed_read_options::ReplicaSelection::location].
        pub fn set_location<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.location = v.into();
            self
        }

        /// Sets the value of [r#type][crate::model::directed_read_options::ReplicaSelection::type].
        pub fn set_type<
            T: std::convert::Into<crate::model::directed_read_options::replica_selection::Type>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.r#type = v.into();
            self
        }
    }

    impl wkt::message::Message for ReplicaSelection {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.DirectedReadOptions.ReplicaSelection"
        }
    }

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

        /// Indicates the type of replica.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Type {
            /// Not specified.
            Unspecified,
            /// Read-write replicas support both reads and writes.
            ReadWrite,
            /// Read-only replicas only support reads (not writes).
            ReadOnly,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [Type::value] or
            /// [Type::name].
            UnknownValue(r#type::UnknownValue),
        }

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

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

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

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

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

        impl std::convert::From<i32> for Type {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::ReadWrite,
                    2 => Self::ReadOnly,
                    _ => Self::UnknownValue(r#type::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for Type {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "TYPE_UNSPECIFIED" => Self::Unspecified,
                    "READ_WRITE" => Self::ReadWrite,
                    "READ_ONLY" => Self::ReadOnly,
                    _ => Self::UnknownValue(r#type::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

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

        impl<'de> serde::de::Deserialize<'de> for Type {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<Type>::new(
                    ".google.spanner.v1.DirectedReadOptions.ReplicaSelection.Type",
                ))
            }
        }
    }

    /// An `IncludeReplicas` contains a repeated set of `ReplicaSelection` which
    /// indicates the order in which replicas should be considered.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct IncludeReplicas {
        /// The directed read replica selector.
        pub replica_selections:
            std::vec::Vec<crate::model::directed_read_options::ReplicaSelection>,

        /// If `true`, Spanner doesn't route requests to a replica outside the
        /// <`include_replicas` list when all of the specified replicas are
        /// unavailable or unhealthy. Default value is `false`.
        pub auto_failover_disabled: bool,

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

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

        /// Sets the value of [replica_selections][crate::model::directed_read_options::IncludeReplicas::replica_selections].
        pub fn set_replica_selections<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<crate::model::directed_read_options::ReplicaSelection>,
        {
            use std::iter::Iterator;
            self.replica_selections = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [auto_failover_disabled][crate::model::directed_read_options::IncludeReplicas::auto_failover_disabled].
        pub fn set_auto_failover_disabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.auto_failover_disabled = v.into();
            self
        }
    }

    impl wkt::message::Message for IncludeReplicas {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.DirectedReadOptions.IncludeReplicas"
        }
    }

    /// An ExcludeReplicas contains a repeated set of ReplicaSelection that should
    /// be excluded from serving requests.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ExcludeReplicas {
        /// The directed read replica selector.
        pub replica_selections:
            std::vec::Vec<crate::model::directed_read_options::ReplicaSelection>,

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

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

        /// Sets the value of [replica_selections][crate::model::directed_read_options::ExcludeReplicas::replica_selections].
        pub fn set_replica_selections<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<crate::model::directed_read_options::ReplicaSelection>,
        {
            use std::iter::Iterator;
            self.replica_selections = v.into_iter().map(|i| i.into()).collect();
            self
        }
    }

    impl wkt::message::Message for ExcludeReplicas {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.DirectedReadOptions.ExcludeReplicas"
        }
    }

    /// Required. At most one of either `include_replicas` or `exclude_replicas`
    /// should be present in the message.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Replicas {
        /// `Include_replicas` indicates the order of replicas (as they appear in
        /// this list) to process the request. If `auto_failover_disabled` is set to
        /// `true` and all replicas are exhausted without finding a healthy replica,
        /// Spanner waits for a replica in the list to become available, requests
        /// might fail due to `DEADLINE_EXCEEDED` errors.
        IncludeReplicas(std::boxed::Box<crate::model::directed_read_options::IncludeReplicas>),
        /// `Exclude_replicas` indicates that specified replicas should be excluded
        /// from serving requests. Spanner doesn't route requests to the replicas
        /// in this list.
        ExcludeReplicas(std::boxed::Box<crate::model::directed_read_options::ExcludeReplicas>),
    }

    impl Replicas {
        /// Initializes the enum to the [IncludeReplicas](Self::IncludeReplicas) branch.
        pub fn from_include_replicas(
            value: impl std::convert::Into<
                std::boxed::Box<crate::model::directed_read_options::IncludeReplicas>,
            >,
        ) -> Self {
            Self::IncludeReplicas(value.into())
        }
        /// Initializes the enum to the [ExcludeReplicas](Self::ExcludeReplicas) branch.
        pub fn from_exclude_replicas(
            value: impl std::convert::Into<
                std::boxed::Box<crate::model::directed_read_options::ExcludeReplicas>,
            >,
        ) -> Self {
            Self::ExcludeReplicas(value.into())
        }
    }
}

/// The request for [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql] and
/// [ExecuteStreamingSql][google.spanner.v1.Spanner.ExecuteStreamingSql].
///
/// [google.spanner.v1.Spanner.ExecuteSql]: crate::client::Spanner::execute_sql
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ExecuteSqlRequest {
    /// Required. The session in which the SQL query should be performed.
    pub session: std::string::String,

    /// The transaction to use.
    ///
    /// For queries, if none is provided, the default is a temporary read-only
    /// transaction with strong concurrency.
    ///
    /// Standard DML statements require a read-write transaction. To protect
    /// against replays, single-use transactions are not supported. The caller
    /// must either supply an existing transaction ID or begin a new transaction.
    ///
    /// Partitioned DML requires an existing Partitioned DML transaction ID.
    pub transaction: std::option::Option<crate::model::TransactionSelector>,

    /// Required. The SQL string.
    pub sql: std::string::String,

    /// Parameter names and values that bind to placeholders in the SQL string.
    ///
    /// A parameter placeholder consists of the `@` character followed by the
    /// parameter name (for example, `@firstName`). Parameter names must conform
    /// to the naming requirements of identifiers as specified at
    /// <https://cloud.google.com/spanner/docs/lexical#identifiers>.
    ///
    /// Parameters can appear anywhere that a literal value is expected. The same
    /// parameter name can be used more than once, for example:
    ///
    /// `"WHERE id > @msg_id AND id < @msg_id + 100"`
    ///
    /// It's an error to execute a SQL statement with unbound parameters.
    pub params: std::option::Option<wkt::Struct>,

    /// It isn't always possible for Cloud Spanner to infer the right SQL type
    /// from a JSON value. For example, values of type `BYTES` and values
    /// of type `STRING` both appear in
    /// [params][google.spanner.v1.ExecuteSqlRequest.params] as JSON strings.
    ///
    /// In these cases, you can use `param_types` to specify the exact
    /// SQL type for some or all of the SQL statement parameters. See the
    /// definition of [Type][google.spanner.v1.Type] for more information
    /// about SQL types.
    ///
    /// [google.spanner.v1.ExecuteSqlRequest.params]: crate::model::ExecuteSqlRequest::params
    /// [google.spanner.v1.Type]: crate::model::Type
    pub param_types: std::collections::HashMap<std::string::String, crate::model::Type>,

    /// If this request is resuming a previously interrupted SQL statement
    /// execution, `resume_token` should be copied from the last
    /// [PartialResultSet][google.spanner.v1.PartialResultSet] yielded before the
    /// interruption. Doing this enables the new SQL statement execution to resume
    /// where the last one left off. The rest of the request parameters must
    /// exactly match the request that yielded this token.
    ///
    /// [google.spanner.v1.PartialResultSet]: crate::model::PartialResultSet
    pub resume_token: ::bytes::Bytes,

    /// Used to control the amount of debugging information returned in
    /// [ResultSetStats][google.spanner.v1.ResultSetStats]. If
    /// [partition_token][google.spanner.v1.ExecuteSqlRequest.partition_token] is
    /// set, [query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode] can only
    /// be set to
    /// [QueryMode.NORMAL][google.spanner.v1.ExecuteSqlRequest.QueryMode.NORMAL].
    ///
    /// [google.spanner.v1.ExecuteSqlRequest.QueryMode.NORMAL]: crate::model::execute_sql_request::QueryMode::Normal
    /// [google.spanner.v1.ExecuteSqlRequest.partition_token]: crate::model::ExecuteSqlRequest::partition_token
    /// [google.spanner.v1.ExecuteSqlRequest.query_mode]: crate::model::ExecuteSqlRequest::query_mode
    /// [google.spanner.v1.ResultSetStats]: crate::model::ResultSetStats
    pub query_mode: crate::model::execute_sql_request::QueryMode,

    /// If present, results are restricted to the specified partition
    /// previously created using `PartitionQuery`. There must be an exact
    /// match for the values of fields common to this message and the
    /// `PartitionQueryRequest` message used to create this `partition_token`.
    pub partition_token: ::bytes::Bytes,

    /// A per-transaction sequence number used to identify this request. This field
    /// makes each request idempotent such that if the request is received multiple
    /// times, at most one succeeds.
    ///
    /// The sequence number must be monotonically increasing within the
    /// transaction. If a request arrives for the first time with an out-of-order
    /// sequence number, the transaction can be aborted. Replays of previously
    /// handled requests yield the same response as the first execution.
    ///
    /// Required for DML statements. Ignored for queries.
    pub seqno: i64,

    /// Query optimizer configuration to use for the given query.
    pub query_options: std::option::Option<crate::model::execute_sql_request::QueryOptions>,

    /// Common options for this request.
    pub request_options: std::option::Option<crate::model::RequestOptions>,

    /// Directed read options for this request.
    pub directed_read_options: std::option::Option<crate::model::DirectedReadOptions>,

    /// If this is for a partitioned query and this field is set to `true`, the
    /// request is executed with Spanner Data Boost independent compute resources.
    ///
    /// If the field is set to `true` but the request doesn't set
    /// `partition_token`, the API returns an `INVALID_ARGUMENT` error.
    pub data_boost_enabled: bool,

    /// Optional. If set to `true`, this statement marks the end of the
    /// transaction. After this statement executes, you must commit or abort the
    /// transaction. Attempts to execute any other requests against this
    /// transaction (including reads and queries) are rejected.
    ///
    /// For DML statements, setting this option might cause some error reporting to
    /// be deferred until commit time (for example, validation of unique
    /// constraints). Given this, successful execution of a DML statement shouldn't
    /// be assumed until a subsequent `Commit` call completes successfully.
    pub last_statement: bool,

    /// Optional. Makes the Spanner requests location-aware if present.
    ///
    /// It gives the server hints that can be used to route the request
    /// to an appropriate server, potentially significantly decreasing latency and
    /// improving throughput. To achieve improved performance, most fields must be
    /// filled in with accurate values.
    pub routing_hint: std::option::Option<crate::model::RoutingHint>,

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

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

    /// Sets the value of [session][crate::model::ExecuteSqlRequest::session].
    pub fn set_session<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.session = v.into();
        self
    }

    /// Sets the value of [transaction][crate::model::ExecuteSqlRequest::transaction].
    pub fn set_transaction<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::TransactionSelector>,
    {
        self.transaction = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [transaction][crate::model::ExecuteSqlRequest::transaction].
    pub fn set_or_clear_transaction<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::TransactionSelector>,
    {
        self.transaction = v.map(|x| x.into());
        self
    }

    /// Sets the value of [sql][crate::model::ExecuteSqlRequest::sql].
    pub fn set_sql<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.sql = v.into();
        self
    }

    /// Sets the value of [params][crate::model::ExecuteSqlRequest::params].
    pub fn set_params<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.params = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [params][crate::model::ExecuteSqlRequest::params].
    pub fn set_or_clear_params<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.params = v.map(|x| x.into());
        self
    }

    /// Sets the value of [param_types][crate::model::ExecuteSqlRequest::param_types].
    pub fn set_param_types<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<crate::model::Type>,
    {
        use std::iter::Iterator;
        self.param_types = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [resume_token][crate::model::ExecuteSqlRequest::resume_token].
    pub fn set_resume_token<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.resume_token = v.into();
        self
    }

    /// Sets the value of [query_mode][crate::model::ExecuteSqlRequest::query_mode].
    pub fn set_query_mode<T: std::convert::Into<crate::model::execute_sql_request::QueryMode>>(
        mut self,
        v: T,
    ) -> Self {
        self.query_mode = v.into();
        self
    }

    /// Sets the value of [partition_token][crate::model::ExecuteSqlRequest::partition_token].
    pub fn set_partition_token<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.partition_token = v.into();
        self
    }

    /// Sets the value of [seqno][crate::model::ExecuteSqlRequest::seqno].
    pub fn set_seqno<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.seqno = v.into();
        self
    }

    /// Sets the value of [query_options][crate::model::ExecuteSqlRequest::query_options].
    pub fn set_query_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::execute_sql_request::QueryOptions>,
    {
        self.query_options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [query_options][crate::model::ExecuteSqlRequest::query_options].
    pub fn set_or_clear_query_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::execute_sql_request::QueryOptions>,
    {
        self.query_options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [request_options][crate::model::ExecuteSqlRequest::request_options].
    pub fn set_request_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RequestOptions>,
    {
        self.request_options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [request_options][crate::model::ExecuteSqlRequest::request_options].
    pub fn set_or_clear_request_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RequestOptions>,
    {
        self.request_options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [directed_read_options][crate::model::ExecuteSqlRequest::directed_read_options].
    pub fn set_directed_read_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DirectedReadOptions>,
    {
        self.directed_read_options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [directed_read_options][crate::model::ExecuteSqlRequest::directed_read_options].
    pub fn set_or_clear_directed_read_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DirectedReadOptions>,
    {
        self.directed_read_options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [data_boost_enabled][crate::model::ExecuteSqlRequest::data_boost_enabled].
    pub fn set_data_boost_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.data_boost_enabled = v.into();
        self
    }

    /// Sets the value of [last_statement][crate::model::ExecuteSqlRequest::last_statement].
    pub fn set_last_statement<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.last_statement = v.into();
        self
    }

    /// Sets the value of [routing_hint][crate::model::ExecuteSqlRequest::routing_hint].
    pub fn set_routing_hint<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RoutingHint>,
    {
        self.routing_hint = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [routing_hint][crate::model::ExecuteSqlRequest::routing_hint].
    pub fn set_or_clear_routing_hint<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RoutingHint>,
    {
        self.routing_hint = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ExecuteSqlRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.ExecuteSqlRequest"
    }
}

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

    /// Query optimizer configuration.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct QueryOptions {
        /// An option to control the selection of optimizer version.
        ///
        /// This parameter allows individual queries to pick different query
        /// optimizer versions.
        ///
        /// Specifying `latest` as a value instructs Cloud Spanner to use the
        /// latest supported query optimizer version. If not specified, Cloud Spanner
        /// uses the optimizer version set at the database level options. Any other
        /// positive integer (from the list of supported optimizer versions)
        /// overrides the default optimizer version for query execution.
        ///
        /// The list of supported optimizer versions can be queried from
        /// `SPANNER_SYS.SUPPORTED_OPTIMIZER_VERSIONS`.
        ///
        /// Executing a SQL statement with an invalid optimizer version fails with
        /// an `INVALID_ARGUMENT` error.
        ///
        /// See
        /// <https://cloud.google.com/spanner/docs/query-optimizer/manage-query-optimizer>
        /// for more information on managing the query optimizer.
        ///
        /// The `optimizer_version` statement hint has precedence over this setting.
        pub optimizer_version: std::string::String,

        /// An option to control the selection of optimizer statistics package.
        ///
        /// This parameter allows individual queries to use a different query
        /// optimizer statistics package.
        ///
        /// Specifying `latest` as a value instructs Cloud Spanner to use the latest
        /// generated statistics package. If not specified, Cloud Spanner uses
        /// the statistics package set at the database level options, or the latest
        /// package if the database option isn't set.
        ///
        /// The statistics package requested by the query has to be exempt from
        /// garbage collection. This can be achieved with the following DDL
        /// statement:
        ///
        /// ```norust
        /// ALTER STATISTICS <package_name> SET OPTIONS (allow_gc=false)
        /// ```
        ///
        /// The list of available statistics packages can be queried from
        /// `INFORMATION_SCHEMA.SPANNER_STATISTICS`.
        ///
        /// Executing a SQL statement with an invalid optimizer statistics package
        /// or with a statistics package that allows garbage collection fails with
        /// an `INVALID_ARGUMENT` error.
        pub optimizer_statistics_package: std::string::String,

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

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

        /// Sets the value of [optimizer_version][crate::model::execute_sql_request::QueryOptions::optimizer_version].
        pub fn set_optimizer_version<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.optimizer_version = v.into();
            self
        }

        /// Sets the value of [optimizer_statistics_package][crate::model::execute_sql_request::QueryOptions::optimizer_statistics_package].
        pub fn set_optimizer_statistics_package<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.optimizer_statistics_package = v.into();
            self
        }
    }

    impl wkt::message::Message for QueryOptions {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.ExecuteSqlRequest.QueryOptions"
        }
    }

    /// Mode in which the statement must be processed.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum QueryMode {
        /// The default mode. Only the statement results are returned.
        Normal,
        /// This mode returns only the query plan, without any results or
        /// execution statistics information.
        Plan,
        /// This mode returns the query plan, overall execution statistics,
        /// operator level execution statistics along with the results. This has a
        /// performance overhead compared to the other modes. It isn't recommended
        /// to use this mode for production traffic.
        Profile,
        /// This mode returns the overall (but not operator-level) execution
        /// statistics along with the results.
        WithStats,
        /// This mode returns the query plan, overall (but not operator-level)
        /// execution statistics along with the results.
        WithPlanAndStats,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [QueryMode::value] or
        /// [QueryMode::name].
        UnknownValue(query_mode::UnknownValue),
    }

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

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

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Normal => std::option::Option::Some("NORMAL"),
                Self::Plan => std::option::Option::Some("PLAN"),
                Self::Profile => std::option::Option::Some("PROFILE"),
                Self::WithStats => std::option::Option::Some("WITH_STATS"),
                Self::WithPlanAndStats => std::option::Option::Some("WITH_PLAN_AND_STATS"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

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

    impl std::convert::From<i32> for QueryMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Normal,
                1 => Self::Plan,
                2 => Self::Profile,
                3 => Self::WithStats,
                4 => Self::WithPlanAndStats,
                _ => Self::UnknownValue(query_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for QueryMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "NORMAL" => Self::Normal,
                "PLAN" => Self::Plan,
                "PROFILE" => Self::Profile,
                "WITH_STATS" => Self::WithStats,
                "WITH_PLAN_AND_STATS" => Self::WithPlanAndStats,
                _ => Self::UnknownValue(query_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for QueryMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Normal => serializer.serialize_i32(0),
                Self::Plan => serializer.serialize_i32(1),
                Self::Profile => serializer.serialize_i32(2),
                Self::WithStats => serializer.serialize_i32(3),
                Self::WithPlanAndStats => serializer.serialize_i32(4),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// The request for [ExecuteBatchDml][google.spanner.v1.Spanner.ExecuteBatchDml].
///
/// [google.spanner.v1.Spanner.ExecuteBatchDml]: crate::client::Spanner::execute_batch_dml
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ExecuteBatchDmlRequest {
    /// Required. The session in which the DML statements should be performed.
    pub session: std::string::String,

    /// Required. The transaction to use. Must be a read-write transaction.
    ///
    /// To protect against replays, single-use transactions are not supported. The
    /// caller must either supply an existing transaction ID or begin a new
    /// transaction.
    pub transaction: std::option::Option<crate::model::TransactionSelector>,

    /// Required. The list of statements to execute in this batch. Statements are
    /// executed serially, such that the effects of statement `i` are visible to
    /// statement `i+1`. Each statement must be a DML statement. Execution stops at
    /// the first failed statement; the remaining statements are not executed.
    ///
    /// Callers must provide at least one statement.
    pub statements: std::vec::Vec<crate::model::execute_batch_dml_request::Statement>,

    /// Required. A per-transaction sequence number used to identify this request.
    /// This field makes each request idempotent such that if the request is
    /// received multiple times, at most one succeeds.
    ///
    /// The sequence number must be monotonically increasing within the
    /// transaction. If a request arrives for the first time with an out-of-order
    /// sequence number, the transaction might be aborted. Replays of previously
    /// handled requests yield the same response as the first execution.
    pub seqno: i64,

    /// Common options for this request.
    pub request_options: std::option::Option<crate::model::RequestOptions>,

    /// Optional. If set to `true`, this request marks the end of the transaction.
    /// After these statements execute, you must commit or abort the transaction.
    /// Attempts to execute any other requests against this transaction
    /// (including reads and queries) are rejected.
    ///
    /// Setting this option might cause some error reporting to be deferred until
    /// commit time (for example, validation of unique constraints). Given this,
    /// successful execution of statements shouldn't be assumed until a subsequent
    /// `Commit` call completes successfully.
    pub last_statements: bool,

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

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

    /// Sets the value of [session][crate::model::ExecuteBatchDmlRequest::session].
    pub fn set_session<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.session = v.into();
        self
    }

    /// Sets the value of [transaction][crate::model::ExecuteBatchDmlRequest::transaction].
    pub fn set_transaction<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::TransactionSelector>,
    {
        self.transaction = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [transaction][crate::model::ExecuteBatchDmlRequest::transaction].
    pub fn set_or_clear_transaction<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::TransactionSelector>,
    {
        self.transaction = v.map(|x| x.into());
        self
    }

    /// Sets the value of [statements][crate::model::ExecuteBatchDmlRequest::statements].
    pub fn set_statements<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::execute_batch_dml_request::Statement>,
    {
        use std::iter::Iterator;
        self.statements = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [seqno][crate::model::ExecuteBatchDmlRequest::seqno].
    pub fn set_seqno<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.seqno = v.into();
        self
    }

    /// Sets the value of [request_options][crate::model::ExecuteBatchDmlRequest::request_options].
    pub fn set_request_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RequestOptions>,
    {
        self.request_options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [request_options][crate::model::ExecuteBatchDmlRequest::request_options].
    pub fn set_or_clear_request_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RequestOptions>,
    {
        self.request_options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [last_statements][crate::model::ExecuteBatchDmlRequest::last_statements].
    pub fn set_last_statements<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.last_statements = v.into();
        self
    }
}

impl wkt::message::Message for ExecuteBatchDmlRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.ExecuteBatchDmlRequest"
    }
}

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

    /// A single DML statement.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Statement {
        /// Required. The DML string.
        pub sql: std::string::String,

        /// Parameter names and values that bind to placeholders in the DML string.
        ///
        /// A parameter placeholder consists of the `@` character followed by the
        /// parameter name (for example, `@firstName`). Parameter names can contain
        /// letters, numbers, and underscores.
        ///
        /// Parameters can appear anywhere that a literal value is expected. The
        /// same parameter name can be used more than once, for example:
        ///
        /// `"WHERE id > @msg_id AND id < @msg_id + 100"`
        ///
        /// It's an error to execute a SQL statement with unbound parameters.
        pub params: std::option::Option<wkt::Struct>,

        /// It isn't always possible for Cloud Spanner to infer the right SQL type
        /// from a JSON value. For example, values of type `BYTES` and values
        /// of type `STRING` both appear in
        /// [params][google.spanner.v1.ExecuteBatchDmlRequest.Statement.params] as
        /// JSON strings.
        ///
        /// In these cases, `param_types` can be used to specify the exact
        /// SQL type for some or all of the SQL statement parameters. See the
        /// definition of [Type][google.spanner.v1.Type] for more information
        /// about SQL types.
        ///
        /// [google.spanner.v1.ExecuteBatchDmlRequest.Statement.params]: crate::model::execute_batch_dml_request::Statement::params
        /// [google.spanner.v1.Type]: crate::model::Type
        pub param_types: std::collections::HashMap<std::string::String, crate::model::Type>,

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

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

        /// Sets the value of [sql][crate::model::execute_batch_dml_request::Statement::sql].
        pub fn set_sql<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.sql = v.into();
            self
        }

        /// Sets the value of [params][crate::model::execute_batch_dml_request::Statement::params].
        pub fn set_params<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Struct>,
        {
            self.params = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [params][crate::model::execute_batch_dml_request::Statement::params].
        pub fn set_or_clear_params<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Struct>,
        {
            self.params = v.map(|x| x.into());
            self
        }

        /// Sets the value of [param_types][crate::model::execute_batch_dml_request::Statement::param_types].
        pub fn set_param_types<T, K, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = (K, V)>,
            K: std::convert::Into<std::string::String>,
            V: std::convert::Into<crate::model::Type>,
        {
            use std::iter::Iterator;
            self.param_types = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
            self
        }
    }

    impl wkt::message::Message for Statement {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.ExecuteBatchDmlRequest.Statement"
        }
    }
}

/// The response for
/// [ExecuteBatchDml][google.spanner.v1.Spanner.ExecuteBatchDml]. Contains a list
/// of [ResultSet][google.spanner.v1.ResultSet] messages, one for each DML
/// statement that has successfully executed, in the same order as the statements
/// in the request. If a statement fails, the status in the response body
/// identifies the cause of the failure.
///
/// To check for DML statements that failed, use the following approach:
///
/// 1. Check the status in the response message. The
///    [google.rpc.Code][google.rpc.Code] enum
///    value `OK` indicates that all statements were executed successfully.
/// 1. If the status was not `OK`, check the number of result sets in the
///    response. If the response contains `N`
///    [ResultSet][google.spanner.v1.ResultSet] messages, then statement `N+1` in
///    the request failed.
///
/// Example 1:
///
/// * Request: 5 DML statements, all executed successfully.
/// * Response: 5 [ResultSet][google.spanner.v1.ResultSet] messages, with the
///   status `OK`.
///
/// Example 2:
///
/// * Request: 5 DML statements. The third statement has a syntax error.
/// * Response: 2 [ResultSet][google.spanner.v1.ResultSet] messages, and a syntax
///   error (`INVALID_ARGUMENT`)
///   status. The number of [ResultSet][google.spanner.v1.ResultSet] messages
///   indicates that the third statement failed, and the fourth and fifth
///   statements were not executed.
///
/// [google.spanner.v1.ResultSet]: crate::model::ResultSet
/// [google.spanner.v1.Spanner.ExecuteBatchDml]: crate::client::Spanner::execute_batch_dml
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ExecuteBatchDmlResponse {
    /// One [ResultSet][google.spanner.v1.ResultSet] for each statement in the
    /// request that ran successfully, in the same order as the statements in the
    /// request. Each [ResultSet][google.spanner.v1.ResultSet] does not contain any
    /// rows. The [ResultSetStats][google.spanner.v1.ResultSetStats] in each
    /// [ResultSet][google.spanner.v1.ResultSet] contain the number of rows
    /// modified by the statement.
    ///
    /// Only the first [ResultSet][google.spanner.v1.ResultSet] in the response
    /// contains valid [ResultSetMetadata][google.spanner.v1.ResultSetMetadata].
    ///
    /// [google.spanner.v1.ResultSet]: crate::model::ResultSet
    /// [google.spanner.v1.ResultSetMetadata]: crate::model::ResultSetMetadata
    /// [google.spanner.v1.ResultSetStats]: crate::model::ResultSetStats
    pub result_sets: std::vec::Vec<crate::model::ResultSet>,

    /// If all DML statements are executed successfully, the status is `OK`.
    /// Otherwise, the error status of the first failed statement.
    pub status: std::option::Option<google_cloud_rpc::model::Status>,

    /// Optional. A precommit token is included if the read-write transaction
    /// is on a multiplexed session. Pass the precommit token with the highest
    /// sequence number from this transaction attempt should be passed to the
    /// [Commit][google.spanner.v1.Spanner.Commit] request for this transaction.
    ///
    /// [google.spanner.v1.Spanner.Commit]: crate::client::Spanner::commit
    pub precommit_token: std::option::Option<crate::model::MultiplexedSessionPrecommitToken>,

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

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

    /// Sets the value of [result_sets][crate::model::ExecuteBatchDmlResponse::result_sets].
    pub fn set_result_sets<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::ResultSet>,
    {
        use std::iter::Iterator;
        self.result_sets = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [status][crate::model::ExecuteBatchDmlResponse::status].
    pub fn set_status<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_rpc::model::Status>,
    {
        self.status = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [status][crate::model::ExecuteBatchDmlResponse::status].
    pub fn set_or_clear_status<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_rpc::model::Status>,
    {
        self.status = v.map(|x| x.into());
        self
    }

    /// Sets the value of [precommit_token][crate::model::ExecuteBatchDmlResponse::precommit_token].
    pub fn set_precommit_token<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MultiplexedSessionPrecommitToken>,
    {
        self.precommit_token = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [precommit_token][crate::model::ExecuteBatchDmlResponse::precommit_token].
    pub fn set_or_clear_precommit_token<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MultiplexedSessionPrecommitToken>,
    {
        self.precommit_token = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ExecuteBatchDmlResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.ExecuteBatchDmlResponse"
    }
}

/// Options for a `PartitionQueryRequest` and `PartitionReadRequest`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PartitionOptions {
    /// **Note:** This hint is currently ignored by `PartitionQuery` and
    /// `PartitionRead` requests.
    ///
    /// The desired data size for each partition generated. The default for this
    /// option is currently 1 GiB. This is only a hint. The actual size of each
    /// partition can be smaller or larger than this size request.
    pub partition_size_bytes: i64,

    /// **Note:** This hint is currently ignored by `PartitionQuery` and
    /// `PartitionRead` requests.
    ///
    /// The desired maximum number of partitions to return. For example, this
    /// might be set to the number of workers available. The default for this
    /// option is currently 10,000. The maximum value is currently 200,000. This
    /// is only a hint. The actual number of partitions returned can be smaller or
    /// larger than this maximum count request.
    pub max_partitions: i64,

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

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

    /// Sets the value of [partition_size_bytes][crate::model::PartitionOptions::partition_size_bytes].
    pub fn set_partition_size_bytes<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.partition_size_bytes = v.into();
        self
    }

    /// Sets the value of [max_partitions][crate::model::PartitionOptions::max_partitions].
    pub fn set_max_partitions<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.max_partitions = v.into();
        self
    }
}

impl wkt::message::Message for PartitionOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.PartitionOptions"
    }
}

/// The request for [PartitionQuery][google.spanner.v1.Spanner.PartitionQuery]
///
/// [google.spanner.v1.Spanner.PartitionQuery]: crate::client::Spanner::partition_query
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PartitionQueryRequest {
    /// Required. The session used to create the partitions.
    pub session: std::string::String,

    /// Read-only snapshot transactions are supported, read and write and
    /// single-use transactions are not.
    pub transaction: std::option::Option<crate::model::TransactionSelector>,

    /// Required. The query request to generate partitions for. The request fails
    /// if the query isn't root partitionable. For a query to be root
    /// partitionable, it needs to satisfy a few conditions. For example, if the
    /// query execution plan contains a distributed union operator, then it must be
    /// the first operator in the plan. For more information about other
    /// conditions, see [Read data in
    /// parallel](https://cloud.google.com/spanner/docs/reads#read_data_in_parallel).
    ///
    /// The query request must not contain DML commands, such as `INSERT`,
    /// `UPDATE`, or `DELETE`. Use
    /// [`ExecuteStreamingSql`][google.spanner.v1.Spanner.ExecuteStreamingSql] with
    /// a `PartitionedDml` transaction for large, partition-friendly DML
    /// operations.
    pub sql: std::string::String,

    /// Optional. Parameter names and values that bind to placeholders in the SQL
    /// string.
    ///
    /// A parameter placeholder consists of the `@` character followed by the
    /// parameter name (for example, `@firstName`). Parameter names can contain
    /// letters, numbers, and underscores.
    ///
    /// Parameters can appear anywhere that a literal value is expected. The same
    /// parameter name can be used more than once, for example:
    ///
    /// `"WHERE id > @msg_id AND id < @msg_id + 100"`
    ///
    /// It's an error to execute a SQL statement with unbound parameters.
    pub params: std::option::Option<wkt::Struct>,

    /// Optional. It isn't always possible for Cloud Spanner to infer the right SQL
    /// type from a JSON value. For example, values of type `BYTES` and values of
    /// type `STRING` both appear in
    /// [params][google.spanner.v1.PartitionQueryRequest.params] as JSON strings.
    ///
    /// In these cases, `param_types` can be used to specify the exact
    /// SQL type for some or all of the SQL query parameters. See the
    /// definition of [Type][google.spanner.v1.Type] for more information
    /// about SQL types.
    ///
    /// [google.spanner.v1.PartitionQueryRequest.params]: crate::model::PartitionQueryRequest::params
    /// [google.spanner.v1.Type]: crate::model::Type
    pub param_types: std::collections::HashMap<std::string::String, crate::model::Type>,

    /// Additional options that affect how many partitions are created.
    pub partition_options: std::option::Option<crate::model::PartitionOptions>,

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

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

    /// Sets the value of [session][crate::model::PartitionQueryRequest::session].
    pub fn set_session<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.session = v.into();
        self
    }

    /// Sets the value of [transaction][crate::model::PartitionQueryRequest::transaction].
    pub fn set_transaction<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::TransactionSelector>,
    {
        self.transaction = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [transaction][crate::model::PartitionQueryRequest::transaction].
    pub fn set_or_clear_transaction<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::TransactionSelector>,
    {
        self.transaction = v.map(|x| x.into());
        self
    }

    /// Sets the value of [sql][crate::model::PartitionQueryRequest::sql].
    pub fn set_sql<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.sql = v.into();
        self
    }

    /// Sets the value of [params][crate::model::PartitionQueryRequest::params].
    pub fn set_params<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.params = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [params][crate::model::PartitionQueryRequest::params].
    pub fn set_or_clear_params<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Struct>,
    {
        self.params = v.map(|x| x.into());
        self
    }

    /// Sets the value of [param_types][crate::model::PartitionQueryRequest::param_types].
    pub fn set_param_types<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<crate::model::Type>,
    {
        use std::iter::Iterator;
        self.param_types = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [partition_options][crate::model::PartitionQueryRequest::partition_options].
    pub fn set_partition_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::PartitionOptions>,
    {
        self.partition_options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [partition_options][crate::model::PartitionQueryRequest::partition_options].
    pub fn set_or_clear_partition_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::PartitionOptions>,
    {
        self.partition_options = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for PartitionQueryRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.PartitionQueryRequest"
    }
}

/// The request for [PartitionRead][google.spanner.v1.Spanner.PartitionRead]
///
/// [google.spanner.v1.Spanner.PartitionRead]: crate::client::Spanner::partition_read
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PartitionReadRequest {
    /// Required. The session used to create the partitions.
    pub session: std::string::String,

    /// Read only snapshot transactions are supported, read/write and single use
    /// transactions are not.
    pub transaction: std::option::Option<crate::model::TransactionSelector>,

    /// Required. The name of the table in the database to be read.
    pub table: std::string::String,

    /// If non-empty, the name of an index on
    /// [table][google.spanner.v1.PartitionReadRequest.table]. This index is used
    /// instead of the table primary key when interpreting
    /// [key_set][google.spanner.v1.PartitionReadRequest.key_set] and sorting
    /// result rows. See [key_set][google.spanner.v1.PartitionReadRequest.key_set]
    /// for further information.
    ///
    /// [google.spanner.v1.PartitionReadRequest.key_set]: crate::model::PartitionReadRequest::key_set
    /// [google.spanner.v1.PartitionReadRequest.table]: crate::model::PartitionReadRequest::table
    pub index: std::string::String,

    /// The columns of [table][google.spanner.v1.PartitionReadRequest.table] to be
    /// returned for each row matching this request.
    ///
    /// [google.spanner.v1.PartitionReadRequest.table]: crate::model::PartitionReadRequest::table
    pub columns: std::vec::Vec<std::string::String>,

    /// Required. `key_set` identifies the rows to be yielded. `key_set` names the
    /// primary keys of the rows in
    /// [table][google.spanner.v1.PartitionReadRequest.table] to be yielded, unless
    /// [index][google.spanner.v1.PartitionReadRequest.index] is present. If
    /// [index][google.spanner.v1.PartitionReadRequest.index] is present, then
    /// [key_set][google.spanner.v1.PartitionReadRequest.key_set] instead names
    /// index keys in [index][google.spanner.v1.PartitionReadRequest.index].
    ///
    /// It isn't an error for the `key_set` to name rows that don't
    /// exist in the database. Read yields nothing for nonexistent rows.
    ///
    /// [google.spanner.v1.PartitionReadRequest.index]: crate::model::PartitionReadRequest::index
    /// [google.spanner.v1.PartitionReadRequest.key_set]: crate::model::PartitionReadRequest::key_set
    /// [google.spanner.v1.PartitionReadRequest.table]: crate::model::PartitionReadRequest::table
    pub key_set: std::option::Option<crate::model::KeySet>,

    /// Additional options that affect how many partitions are created.
    pub partition_options: std::option::Option<crate::model::PartitionOptions>,

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

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

    /// Sets the value of [session][crate::model::PartitionReadRequest::session].
    pub fn set_session<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.session = v.into();
        self
    }

    /// Sets the value of [transaction][crate::model::PartitionReadRequest::transaction].
    pub fn set_transaction<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::TransactionSelector>,
    {
        self.transaction = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [transaction][crate::model::PartitionReadRequest::transaction].
    pub fn set_or_clear_transaction<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::TransactionSelector>,
    {
        self.transaction = v.map(|x| x.into());
        self
    }

    /// Sets the value of [table][crate::model::PartitionReadRequest::table].
    pub fn set_table<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.table = v.into();
        self
    }

    /// Sets the value of [index][crate::model::PartitionReadRequest::index].
    pub fn set_index<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.index = v.into();
        self
    }

    /// Sets the value of [columns][crate::model::PartitionReadRequest::columns].
    pub fn set_columns<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.columns = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [key_set][crate::model::PartitionReadRequest::key_set].
    pub fn set_key_set<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::KeySet>,
    {
        self.key_set = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [key_set][crate::model::PartitionReadRequest::key_set].
    pub fn set_or_clear_key_set<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::KeySet>,
    {
        self.key_set = v.map(|x| x.into());
        self
    }

    /// Sets the value of [partition_options][crate::model::PartitionReadRequest::partition_options].
    pub fn set_partition_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::PartitionOptions>,
    {
        self.partition_options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [partition_options][crate::model::PartitionReadRequest::partition_options].
    pub fn set_or_clear_partition_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::PartitionOptions>,
    {
        self.partition_options = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for PartitionReadRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.PartitionReadRequest"
    }
}

/// Information returned for each partition returned in a
/// PartitionResponse.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Partition {
    /// This token can be passed to `Read`, `StreamingRead`, `ExecuteSql`, or
    /// `ExecuteStreamingSql` requests to restrict the results to those identified
    /// by this partition token.
    pub partition_token: ::bytes::Bytes,

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

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

    /// Sets the value of [partition_token][crate::model::Partition::partition_token].
    pub fn set_partition_token<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.partition_token = v.into();
        self
    }
}

impl wkt::message::Message for Partition {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.Partition"
    }
}

/// The response for [PartitionQuery][google.spanner.v1.Spanner.PartitionQuery]
/// or [PartitionRead][google.spanner.v1.Spanner.PartitionRead]
///
/// [google.spanner.v1.Spanner.PartitionQuery]: crate::client::Spanner::partition_query
/// [google.spanner.v1.Spanner.PartitionRead]: crate::client::Spanner::partition_read
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PartitionResponse {
    /// Partitions created by this request.
    pub partitions: std::vec::Vec<crate::model::Partition>,

    /// Transaction created by this request.
    pub transaction: std::option::Option<crate::model::Transaction>,

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

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

    /// Sets the value of [partitions][crate::model::PartitionResponse::partitions].
    pub fn set_partitions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Partition>,
    {
        use std::iter::Iterator;
        self.partitions = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [transaction][crate::model::PartitionResponse::transaction].
    pub fn set_transaction<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Transaction>,
    {
        self.transaction = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [transaction][crate::model::PartitionResponse::transaction].
    pub fn set_or_clear_transaction<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Transaction>,
    {
        self.transaction = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for PartitionResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.PartitionResponse"
    }
}

/// The request for [Read][google.spanner.v1.Spanner.Read] and
/// [StreamingRead][google.spanner.v1.Spanner.StreamingRead].
///
/// [google.spanner.v1.Spanner.Read]: crate::client::Spanner::read
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ReadRequest {
    /// Required. The session in which the read should be performed.
    pub session: std::string::String,

    /// The transaction to use. If none is provided, the default is a
    /// temporary read-only transaction with strong concurrency.
    pub transaction: std::option::Option<crate::model::TransactionSelector>,

    /// Required. The name of the table in the database to be read.
    pub table: std::string::String,

    /// If non-empty, the name of an index on
    /// [table][google.spanner.v1.ReadRequest.table]. This index is used instead of
    /// the table primary key when interpreting
    /// [key_set][google.spanner.v1.ReadRequest.key_set] and sorting result rows.
    /// See [key_set][google.spanner.v1.ReadRequest.key_set] for further
    /// information.
    ///
    /// [google.spanner.v1.ReadRequest.key_set]: crate::model::ReadRequest::key_set
    /// [google.spanner.v1.ReadRequest.table]: crate::model::ReadRequest::table
    pub index: std::string::String,

    /// Required. The columns of [table][google.spanner.v1.ReadRequest.table] to be
    /// returned for each row matching this request.
    ///
    /// [google.spanner.v1.ReadRequest.table]: crate::model::ReadRequest::table
    pub columns: std::vec::Vec<std::string::String>,

    /// Required. `key_set` identifies the rows to be yielded. `key_set` names the
    /// primary keys of the rows in [table][google.spanner.v1.ReadRequest.table] to
    /// be yielded, unless [index][google.spanner.v1.ReadRequest.index] is present.
    /// If [index][google.spanner.v1.ReadRequest.index] is present, then
    /// [key_set][google.spanner.v1.ReadRequest.key_set] instead names index keys
    /// in [index][google.spanner.v1.ReadRequest.index].
    ///
    /// If the [partition_token][google.spanner.v1.ReadRequest.partition_token]
    /// field is empty, rows are yielded in table primary key order (if
    /// [index][google.spanner.v1.ReadRequest.index] is empty) or index key order
    /// (if [index][google.spanner.v1.ReadRequest.index] is non-empty). If the
    /// [partition_token][google.spanner.v1.ReadRequest.partition_token] field
    /// isn't empty, rows are yielded in an unspecified order.
    ///
    /// It isn't an error for the `key_set` to name rows that don't
    /// exist in the database. Read yields nothing for nonexistent rows.
    ///
    /// [google.spanner.v1.ReadRequest.index]: crate::model::ReadRequest::index
    /// [google.spanner.v1.ReadRequest.key_set]: crate::model::ReadRequest::key_set
    /// [google.spanner.v1.ReadRequest.partition_token]: crate::model::ReadRequest::partition_token
    /// [google.spanner.v1.ReadRequest.table]: crate::model::ReadRequest::table
    pub key_set: std::option::Option<crate::model::KeySet>,

    /// If greater than zero, only the first `limit` rows are yielded. If `limit`
    /// is zero, the default is no limit. A limit can't be specified if
    /// `partition_token` is set.
    pub limit: i64,

    /// If this request is resuming a previously interrupted read,
    /// `resume_token` should be copied from the last
    /// [PartialResultSet][google.spanner.v1.PartialResultSet] yielded before the
    /// interruption. Doing this enables the new read to resume where the last read
    /// left off. The rest of the request parameters must exactly match the request
    /// that yielded this token.
    ///
    /// [google.spanner.v1.PartialResultSet]: crate::model::PartialResultSet
    pub resume_token: ::bytes::Bytes,

    /// If present, results are restricted to the specified partition
    /// previously created using `PartitionRead`. There must be an exact
    /// match for the values of fields common to this message and the
    /// PartitionReadRequest message used to create this partition_token.
    pub partition_token: ::bytes::Bytes,

    /// Common options for this request.
    pub request_options: std::option::Option<crate::model::RequestOptions>,

    /// Directed read options for this request.
    pub directed_read_options: std::option::Option<crate::model::DirectedReadOptions>,

    /// If this is for a partitioned read and this field is set to `true`, the
    /// request is executed with Spanner Data Boost independent compute resources.
    ///
    /// If the field is set to `true` but the request doesn't set
    /// `partition_token`, the API returns an `INVALID_ARGUMENT` error.
    pub data_boost_enabled: bool,

    /// Optional. Order for the returned rows.
    ///
    /// By default, Spanner returns result rows in primary key order except for
    /// PartitionRead requests. For applications that don't require rows to be
    /// returned in primary key (`ORDER_BY_PRIMARY_KEY`) order, setting
    /// `ORDER_BY_NO_ORDER` option allows Spanner to optimize row retrieval,
    /// resulting in lower latencies in certain cases (for example, bulk point
    /// lookups).
    pub order_by: crate::model::read_request::OrderBy,

    /// Optional. Lock Hint for the request, it can only be used with read-write
    /// transactions.
    pub lock_hint: crate::model::read_request::LockHint,

    /// Optional. Makes the Spanner requests location-aware if present.
    ///
    /// It gives the server hints that can be used to route the request
    /// to an appropriate server, potentially significantly decreasing latency and
    /// improving throughput. To achieve improved performance, most fields must be
    /// filled in with accurate values.
    pub routing_hint: std::option::Option<crate::model::RoutingHint>,

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

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

    /// Sets the value of [session][crate::model::ReadRequest::session].
    pub fn set_session<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.session = v.into();
        self
    }

    /// Sets the value of [transaction][crate::model::ReadRequest::transaction].
    pub fn set_transaction<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::TransactionSelector>,
    {
        self.transaction = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [transaction][crate::model::ReadRequest::transaction].
    pub fn set_or_clear_transaction<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::TransactionSelector>,
    {
        self.transaction = v.map(|x| x.into());
        self
    }

    /// Sets the value of [table][crate::model::ReadRequest::table].
    pub fn set_table<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.table = v.into();
        self
    }

    /// Sets the value of [index][crate::model::ReadRequest::index].
    pub fn set_index<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.index = v.into();
        self
    }

    /// Sets the value of [columns][crate::model::ReadRequest::columns].
    pub fn set_columns<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.columns = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [key_set][crate::model::ReadRequest::key_set].
    pub fn set_key_set<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::KeySet>,
    {
        self.key_set = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [key_set][crate::model::ReadRequest::key_set].
    pub fn set_or_clear_key_set<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::KeySet>,
    {
        self.key_set = v.map(|x| x.into());
        self
    }

    /// Sets the value of [limit][crate::model::ReadRequest::limit].
    pub fn set_limit<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.limit = v.into();
        self
    }

    /// Sets the value of [resume_token][crate::model::ReadRequest::resume_token].
    pub fn set_resume_token<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.resume_token = v.into();
        self
    }

    /// Sets the value of [partition_token][crate::model::ReadRequest::partition_token].
    pub fn set_partition_token<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.partition_token = v.into();
        self
    }

    /// Sets the value of [request_options][crate::model::ReadRequest::request_options].
    pub fn set_request_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RequestOptions>,
    {
        self.request_options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [request_options][crate::model::ReadRequest::request_options].
    pub fn set_or_clear_request_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RequestOptions>,
    {
        self.request_options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [directed_read_options][crate::model::ReadRequest::directed_read_options].
    pub fn set_directed_read_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DirectedReadOptions>,
    {
        self.directed_read_options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [directed_read_options][crate::model::ReadRequest::directed_read_options].
    pub fn set_or_clear_directed_read_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DirectedReadOptions>,
    {
        self.directed_read_options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [data_boost_enabled][crate::model::ReadRequest::data_boost_enabled].
    pub fn set_data_boost_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.data_boost_enabled = v.into();
        self
    }

    /// Sets the value of [order_by][crate::model::ReadRequest::order_by].
    pub fn set_order_by<T: std::convert::Into<crate::model::read_request::OrderBy>>(
        mut self,
        v: T,
    ) -> Self {
        self.order_by = v.into();
        self
    }

    /// Sets the value of [lock_hint][crate::model::ReadRequest::lock_hint].
    pub fn set_lock_hint<T: std::convert::Into<crate::model::read_request::LockHint>>(
        mut self,
        v: T,
    ) -> Self {
        self.lock_hint = v.into();
        self
    }

    /// Sets the value of [routing_hint][crate::model::ReadRequest::routing_hint].
    pub fn set_routing_hint<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RoutingHint>,
    {
        self.routing_hint = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [routing_hint][crate::model::ReadRequest::routing_hint].
    pub fn set_or_clear_routing_hint<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RoutingHint>,
    {
        self.routing_hint = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ReadRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.ReadRequest"
    }
}

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

    /// An option to control the order in which rows are returned from a read.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum OrderBy {
        /// Default value.
        ///
        /// `ORDER_BY_UNSPECIFIED` is equivalent to `ORDER_BY_PRIMARY_KEY`.
        Unspecified,
        /// Read rows are returned in primary key order.
        ///
        /// In the event that this option is used in conjunction with the
        /// `partition_token` field, the API returns an `INVALID_ARGUMENT` error.
        PrimaryKey,
        /// Read rows are returned in any order.
        NoOrder,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [OrderBy::value] or
        /// [OrderBy::name].
        UnknownValue(order_by::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for OrderBy {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::PrimaryKey,
                2 => Self::NoOrder,
                _ => Self::UnknownValue(order_by::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for OrderBy {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "ORDER_BY_UNSPECIFIED" => Self::Unspecified,
                "ORDER_BY_PRIMARY_KEY" => Self::PrimaryKey,
                "ORDER_BY_NO_ORDER" => Self::NoOrder,
                _ => Self::UnknownValue(order_by::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

    /// A lock hint mechanism for reads done within a transaction.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum LockHint {
        /// Default value.
        ///
        /// `LOCK_HINT_UNSPECIFIED` is equivalent to `LOCK_HINT_SHARED`.
        Unspecified,
        /// Acquire shared locks.
        ///
        /// By default when you perform a read as part of a read-write transaction,
        /// Spanner acquires shared read locks, which allows other reads to still
        /// access the data until your transaction is ready to commit. When your
        /// transaction is committing and writes are being applied, the transaction
        /// attempts to upgrade to an exclusive lock for any data you are writing.
        /// For more information about locks, see [Lock
        /// modes](https://cloud.google.com/spanner/docs/introspection/lock-statistics#explain-lock-modes).
        Shared,
        /// Acquire exclusive locks.
        ///
        /// Requesting exclusive locks is beneficial if you observe high write
        /// contention, which means you notice that multiple transactions are
        /// concurrently trying to read and write to the same data, resulting in a
        /// large number of aborts. This problem occurs when two transactions
        /// initially acquire shared locks and then both try to upgrade to exclusive
        /// locks at the same time. In this situation both transactions are waiting
        /// for the other to give up their lock, resulting in a deadlocked situation.
        /// Spanner is able to detect this occurring and force one of the
        /// transactions to abort. However, this is a slow and expensive operation
        /// and results in lower performance. In this case it makes sense to acquire
        /// exclusive locks at the start of the transaction because then when
        /// multiple transactions try to act on the same data, they automatically get
        /// serialized. Each transaction waits its turn to acquire the lock and
        /// avoids getting into deadlock situations.
        ///
        /// Because the exclusive lock hint is just a hint, it shouldn't be
        /// considered equivalent to a mutex. In other words, you shouldn't use
        /// Spanner exclusive locks as a mutual exclusion mechanism for the execution
        /// of code outside of Spanner.
        ///
        /// **Note:** Request exclusive locks judiciously because they block others
        /// from reading that data for the entire transaction, rather than just when
        /// the writes are being performed. Unless you observe high write contention,
        /// you should use the default of shared read locks so you don't prematurely
        /// block other clients from reading the data that you're writing to.
        Exclusive,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [LockHint::value] or
        /// [LockHint::name].
        UnknownValue(lock_hint::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for LockHint {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Shared,
                2 => Self::Exclusive,
                _ => Self::UnknownValue(lock_hint::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for LockHint {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "LOCK_HINT_UNSPECIFIED" => Self::Unspecified,
                "LOCK_HINT_SHARED" => Self::Shared,
                "LOCK_HINT_EXCLUSIVE" => Self::Exclusive,
                _ => Self::UnknownValue(lock_hint::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// The request for
/// [BeginTransaction][google.spanner.v1.Spanner.BeginTransaction].
///
/// [google.spanner.v1.Spanner.BeginTransaction]: crate::client::Spanner::begin_transaction
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BeginTransactionRequest {
    /// Required. The session in which the transaction runs.
    pub session: std::string::String,

    /// Required. Options for the new transaction.
    pub options: std::option::Option<crate::model::TransactionOptions>,

    /// Common options for this request.
    /// Priority is ignored for this request. Setting the priority in this
    /// `request_options` struct doesn't do anything. To set the priority for a
    /// transaction, set it on the reads and writes that are part of this
    /// transaction instead.
    pub request_options: std::option::Option<crate::model::RequestOptions>,

    /// Optional. Required for read-write transactions on a multiplexed session
    /// that commit mutations but don't perform any reads or queries. You must
    /// randomly select one of the mutations from the mutation set and send it as a
    /// part of this request.
    pub mutation_key: std::option::Option<crate::model::Mutation>,

    /// Optional. Makes the Spanner requests location-aware if present.
    ///
    /// It gives the server hints that can be used to route the request
    /// to an appropriate server, potentially significantly decreasing latency and
    /// improving throughput. To achieve improved performance, most fields must be
    /// filled in with accurate values.
    pub routing_hint: std::option::Option<crate::model::RoutingHint>,

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

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

    /// Sets the value of [session][crate::model::BeginTransactionRequest::session].
    pub fn set_session<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.session = v.into();
        self
    }

    /// Sets the value of [options][crate::model::BeginTransactionRequest::options].
    pub fn set_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::TransactionOptions>,
    {
        self.options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [options][crate::model::BeginTransactionRequest::options].
    pub fn set_or_clear_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::TransactionOptions>,
    {
        self.options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [request_options][crate::model::BeginTransactionRequest::request_options].
    pub fn set_request_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RequestOptions>,
    {
        self.request_options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [request_options][crate::model::BeginTransactionRequest::request_options].
    pub fn set_or_clear_request_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RequestOptions>,
    {
        self.request_options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [mutation_key][crate::model::BeginTransactionRequest::mutation_key].
    pub fn set_mutation_key<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Mutation>,
    {
        self.mutation_key = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [mutation_key][crate::model::BeginTransactionRequest::mutation_key].
    pub fn set_or_clear_mutation_key<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Mutation>,
    {
        self.mutation_key = v.map(|x| x.into());
        self
    }

    /// Sets the value of [routing_hint][crate::model::BeginTransactionRequest::routing_hint].
    pub fn set_routing_hint<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RoutingHint>,
    {
        self.routing_hint = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [routing_hint][crate::model::BeginTransactionRequest::routing_hint].
    pub fn set_or_clear_routing_hint<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RoutingHint>,
    {
        self.routing_hint = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for BeginTransactionRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.BeginTransactionRequest"
    }
}

/// The request for [Commit][google.spanner.v1.Spanner.Commit].
///
/// [google.spanner.v1.Spanner.Commit]: crate::client::Spanner::commit
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CommitRequest {
    /// Required. The session in which the transaction to be committed is running.
    pub session: std::string::String,

    /// The mutations to be executed when this transaction commits. All
    /// mutations are applied atomically, in the order they appear in
    /// this list.
    pub mutations: std::vec::Vec<crate::model::Mutation>,

    /// If `true`, then statistics related to the transaction is included in
    /// the [CommitResponse][google.spanner.v1.CommitResponse.commit_stats].
    /// Default value is `false`.
    ///
    /// [google.spanner.v1.CommitResponse.commit_stats]: crate::model::CommitResponse::commit_stats
    pub return_commit_stats: bool,

    /// Optional. The amount of latency this request is configured to incur in
    /// order to improve throughput. If this field isn't set, Spanner assumes
    /// requests are relatively latency sensitive and automatically determines an
    /// appropriate delay time. You can specify a commit delay value between 0 and
    /// 500 ms.
    pub max_commit_delay: std::option::Option<wkt::Duration>,

    /// Common options for this request.
    pub request_options: std::option::Option<crate::model::RequestOptions>,

    /// Optional. If the read-write transaction was executed on a multiplexed
    /// session, then you must include the precommit token with the highest
    /// sequence number received in this transaction attempt. Failing to do so
    /// results in a `FailedPrecondition` error.
    pub precommit_token: std::option::Option<crate::model::MultiplexedSessionPrecommitToken>,

    /// Optional. Makes the Spanner requests location-aware if present.
    ///
    /// It gives the server hints that can be used to route the request
    /// to an appropriate server, potentially significantly decreasing latency and
    /// improving throughput. To achieve improved performance, most fields must be
    /// filled in with accurate values.
    pub routing_hint: std::option::Option<crate::model::RoutingHint>,

    /// Required. The transaction in which to commit.
    pub transaction: std::option::Option<crate::model::commit_request::Transaction>,

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

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

    /// Sets the value of [session][crate::model::CommitRequest::session].
    pub fn set_session<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.session = v.into();
        self
    }

    /// Sets the value of [mutations][crate::model::CommitRequest::mutations].
    pub fn set_mutations<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Mutation>,
    {
        use std::iter::Iterator;
        self.mutations = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [return_commit_stats][crate::model::CommitRequest::return_commit_stats].
    pub fn set_return_commit_stats<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.return_commit_stats = v.into();
        self
    }

    /// Sets the value of [max_commit_delay][crate::model::CommitRequest::max_commit_delay].
    pub fn set_max_commit_delay<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.max_commit_delay = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [max_commit_delay][crate::model::CommitRequest::max_commit_delay].
    pub fn set_or_clear_max_commit_delay<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.max_commit_delay = v.map(|x| x.into());
        self
    }

    /// Sets the value of [request_options][crate::model::CommitRequest::request_options].
    pub fn set_request_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RequestOptions>,
    {
        self.request_options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [request_options][crate::model::CommitRequest::request_options].
    pub fn set_or_clear_request_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RequestOptions>,
    {
        self.request_options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [precommit_token][crate::model::CommitRequest::precommit_token].
    pub fn set_precommit_token<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MultiplexedSessionPrecommitToken>,
    {
        self.precommit_token = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [precommit_token][crate::model::CommitRequest::precommit_token].
    pub fn set_or_clear_precommit_token<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MultiplexedSessionPrecommitToken>,
    {
        self.precommit_token = v.map(|x| x.into());
        self
    }

    /// Sets the value of [routing_hint][crate::model::CommitRequest::routing_hint].
    pub fn set_routing_hint<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RoutingHint>,
    {
        self.routing_hint = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [routing_hint][crate::model::CommitRequest::routing_hint].
    pub fn set_or_clear_routing_hint<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RoutingHint>,
    {
        self.routing_hint = v.map(|x| x.into());
        self
    }

    /// Sets the value of [transaction][crate::model::CommitRequest::transaction].
    ///
    /// Note that all the setters affecting `transaction` are mutually
    /// exclusive.
    pub fn set_transaction<
        T: std::convert::Into<std::option::Option<crate::model::commit_request::Transaction>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.transaction = v.into();
        self
    }

    /// The value of [transaction][crate::model::CommitRequest::transaction]
    /// if it holds a `TransactionId`, `None` if the field is not set or
    /// holds a different branch.
    pub fn transaction_id(&self) -> std::option::Option<&::bytes::Bytes> {
        #[allow(unreachable_patterns)]
        self.transaction.as_ref().and_then(|v| match v {
            crate::model::commit_request::Transaction::TransactionId(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [transaction][crate::model::CommitRequest::transaction]
    /// to hold a `TransactionId`.
    ///
    /// Note that all the setters affecting `transaction` are
    /// mutually exclusive.
    pub fn set_transaction_id<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.transaction = std::option::Option::Some(
            crate::model::commit_request::Transaction::TransactionId(v.into()),
        );
        self
    }

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

    /// Sets the value of [transaction][crate::model::CommitRequest::transaction]
    /// to hold a `SingleUseTransaction`.
    ///
    /// Note that all the setters affecting `transaction` are
    /// mutually exclusive.
    pub fn set_single_use_transaction<
        T: std::convert::Into<std::boxed::Box<crate::model::TransactionOptions>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.transaction = std::option::Option::Some(
            crate::model::commit_request::Transaction::SingleUseTransaction(v.into()),
        );
        self
    }
}

impl wkt::message::Message for CommitRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.CommitRequest"
    }
}

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

    /// Required. The transaction in which to commit.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Transaction {
        /// Commit a previously-started transaction.
        TransactionId(::bytes::Bytes),
        /// Execute mutations in a temporary transaction. Note that unlike
        /// commit of a previously-started transaction, commit with a
        /// temporary transaction is non-idempotent. That is, if the
        /// `CommitRequest` is sent to Cloud Spanner more than once (for
        /// instance, due to retries in the application, or in the
        /// transport library), it's possible that the mutations are
        /// executed more than once. If this is undesirable, use
        /// [BeginTransaction][google.spanner.v1.Spanner.BeginTransaction] and
        /// [Commit][google.spanner.v1.Spanner.Commit] instead.
        ///
        /// [google.spanner.v1.Spanner.BeginTransaction]: crate::client::Spanner::begin_transaction
        /// [google.spanner.v1.Spanner.Commit]: crate::client::Spanner::commit
        SingleUseTransaction(std::boxed::Box<crate::model::TransactionOptions>),
    }

    impl Transaction {
        /// Initializes the enum to the [TransactionId](Self::TransactionId) branch.
        pub fn from_transaction_id(value: impl std::convert::Into<::bytes::Bytes>) -> Self {
            Self::TransactionId(value.into())
        }
        /// Initializes the enum to the [SingleUseTransaction](Self::SingleUseTransaction) branch.
        pub fn from_single_use_transaction(
            value: impl std::convert::Into<std::boxed::Box<crate::model::TransactionOptions>>,
        ) -> Self {
            Self::SingleUseTransaction(value.into())
        }
    }
}

/// The request for [Rollback][google.spanner.v1.Spanner.Rollback].
///
/// [google.spanner.v1.Spanner.Rollback]: crate::client::Spanner::rollback
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RollbackRequest {
    /// Required. The session in which the transaction to roll back is running.
    pub session: std::string::String,

    /// Required. The transaction to roll back.
    pub transaction_id: ::bytes::Bytes,

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

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

    /// Sets the value of [session][crate::model::RollbackRequest::session].
    pub fn set_session<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.session = v.into();
        self
    }

    /// Sets the value of [transaction_id][crate::model::RollbackRequest::transaction_id].
    pub fn set_transaction_id<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.transaction_id = v.into();
        self
    }
}

impl wkt::message::Message for RollbackRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.RollbackRequest"
    }
}

/// The request for [BatchWrite][google.spanner.v1.Spanner.BatchWrite].
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchWriteRequest {
    /// Required. The session in which the batch request is to be run.
    pub session: std::string::String,

    /// Common options for this request.
    pub request_options: std::option::Option<crate::model::RequestOptions>,

    /// Required. The groups of mutations to be applied.
    pub mutation_groups: std::vec::Vec<crate::model::batch_write_request::MutationGroup>,

    /// Optional. If you don't set the `exclude_txn_from_change_streams` option or
    /// if it's set to `false`, then any change streams monitoring columns modified
    /// by transactions will capture the updates made within that transaction.
    pub exclude_txn_from_change_streams: bool,

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

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

    /// Sets the value of [session][crate::model::BatchWriteRequest::session].
    pub fn set_session<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.session = v.into();
        self
    }

    /// Sets the value of [request_options][crate::model::BatchWriteRequest::request_options].
    pub fn set_request_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RequestOptions>,
    {
        self.request_options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [request_options][crate::model::BatchWriteRequest::request_options].
    pub fn set_or_clear_request_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RequestOptions>,
    {
        self.request_options = v.map(|x| x.into());
        self
    }

    /// Sets the value of [mutation_groups][crate::model::BatchWriteRequest::mutation_groups].
    pub fn set_mutation_groups<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::batch_write_request::MutationGroup>,
    {
        use std::iter::Iterator;
        self.mutation_groups = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [exclude_txn_from_change_streams][crate::model::BatchWriteRequest::exclude_txn_from_change_streams].
    pub fn set_exclude_txn_from_change_streams<T: std::convert::Into<bool>>(
        mut self,
        v: T,
    ) -> Self {
        self.exclude_txn_from_change_streams = v.into();
        self
    }
}

impl wkt::message::Message for BatchWriteRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.BatchWriteRequest"
    }
}

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

    /// A group of mutations to be committed together. Related mutations should be
    /// placed in a group. For example, two mutations inserting rows with the same
    /// primary key prefix in both parent and child tables are related.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct MutationGroup {
        /// Required. The mutations in this group.
        pub mutations: std::vec::Vec<crate::model::Mutation>,

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

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

        /// Sets the value of [mutations][crate::model::batch_write_request::MutationGroup::mutations].
        pub fn set_mutations<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<crate::model::Mutation>,
        {
            use std::iter::Iterator;
            self.mutations = v.into_iter().map(|i| i.into()).collect();
            self
        }
    }

    impl wkt::message::Message for MutationGroup {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.BatchWriteRequest.MutationGroup"
        }
    }
}

/// The result of applying a batch of mutations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchWriteResponse {
    /// The mutation groups applied in this batch. The values index into the
    /// `mutation_groups` field in the corresponding `BatchWriteRequest`.
    pub indexes: std::vec::Vec<i32>,

    /// An `OK` status indicates success. Any other status indicates a failure.
    pub status: std::option::Option<google_cloud_rpc::model::Status>,

    /// The commit timestamp of the transaction that applied this batch.
    /// Present if status is OK and the mutation groups were applied, absent
    /// otherwise.
    ///
    /// For mutation groups with conditions, a status=OK and missing
    /// commit_timestamp means that the mutation groups were not applied due to the
    /// condition not being satisfied after evaluation.
    pub commit_timestamp: std::option::Option<wkt::Timestamp>,

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

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

    /// Sets the value of [indexes][crate::model::BatchWriteResponse::indexes].
    pub fn set_indexes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<i32>,
    {
        use std::iter::Iterator;
        self.indexes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [status][crate::model::BatchWriteResponse::status].
    pub fn set_status<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_rpc::model::Status>,
    {
        self.status = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [status][crate::model::BatchWriteResponse::status].
    pub fn set_or_clear_status<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_rpc::model::Status>,
    {
        self.status = v.map(|x| x.into());
        self
    }

    /// Sets the value of [commit_timestamp][crate::model::BatchWriteResponse::commit_timestamp].
    pub fn set_commit_timestamp<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.commit_timestamp = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [commit_timestamp][crate::model::BatchWriteResponse::commit_timestamp].
    pub fn set_or_clear_commit_timestamp<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.commit_timestamp = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for BatchWriteResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.BatchWriteResponse"
    }
}

/// The request for
/// [FetchCacheUpdate][google.spanner.v1.Spanner.FetchCacheUpdate].
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FetchCacheUpdateRequest {
    /// Required. The database for which to retrieve the cache update.
    pub database: std::string::String,

    /// Optional. The maximum number of key recipes to return in the response.
    /// If not set, a default limit of 100 will be used.
    pub max_recipe_count: i32,

    /// Optional. The maximum number of ranges to return in the response.
    /// If not set, a default limit of 10000 will be used.
    pub max_range_count: i32,

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

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

    /// Sets the value of [database][crate::model::FetchCacheUpdateRequest::database].
    pub fn set_database<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.database = v.into();
        self
    }

    /// Sets the value of [max_recipe_count][crate::model::FetchCacheUpdateRequest::max_recipe_count].
    pub fn set_max_recipe_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.max_recipe_count = v.into();
        self
    }

    /// Sets the value of [max_range_count][crate::model::FetchCacheUpdateRequest::max_range_count].
    pub fn set_max_range_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.max_range_count = v.into();
        self
    }
}

impl wkt::message::Message for FetchCacheUpdateRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.FetchCacheUpdateRequest"
    }
}

/// Options to use for transactions.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TransactionOptions {
    /// When `exclude_txn_from_change_streams` is set to `true`, it prevents read
    /// or write transactions from being tracked in change streams.
    ///
    /// * If the DDL option `allow_txn_exclusion` is set to `true`, then the
    ///   updates
    ///   made within this transaction aren't recorded in the change stream.
    ///
    /// * If you don't set the DDL option `allow_txn_exclusion` or if it's
    ///   set to `false`, then the updates made within this transaction are
    ///   recorded in the change stream.
    ///
    ///
    /// When `exclude_txn_from_change_streams` is set to `false` or not set,
    /// modifications from this transaction are recorded in all change streams
    /// that are tracking columns modified by these transactions.
    ///
    /// The `exclude_txn_from_change_streams` option can only be specified
    /// for read-write or partitioned DML transactions, otherwise the API returns
    /// an `INVALID_ARGUMENT` error.
    pub exclude_txn_from_change_streams: bool,

    /// Isolation level for the transaction.
    pub isolation_level: crate::model::transaction_options::IsolationLevel,

    /// Required. The type of transaction.
    pub mode: std::option::Option<crate::model::transaction_options::Mode>,

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

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

    /// Sets the value of [exclude_txn_from_change_streams][crate::model::TransactionOptions::exclude_txn_from_change_streams].
    pub fn set_exclude_txn_from_change_streams<T: std::convert::Into<bool>>(
        mut self,
        v: T,
    ) -> Self {
        self.exclude_txn_from_change_streams = v.into();
        self
    }

    /// Sets the value of [isolation_level][crate::model::TransactionOptions::isolation_level].
    pub fn set_isolation_level<
        T: std::convert::Into<crate::model::transaction_options::IsolationLevel>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.isolation_level = v.into();
        self
    }

    /// Sets the value of [mode][crate::model::TransactionOptions::mode].
    ///
    /// Note that all the setters affecting `mode` are mutually
    /// exclusive.
    pub fn set_mode<
        T: std::convert::Into<std::option::Option<crate::model::transaction_options::Mode>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.mode = v.into();
        self
    }

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

    /// Sets the value of [mode][crate::model::TransactionOptions::mode]
    /// to hold a `ReadWrite`.
    ///
    /// Note that all the setters affecting `mode` are
    /// mutually exclusive.
    pub fn set_read_write<
        T: std::convert::Into<std::boxed::Box<crate::model::transaction_options::ReadWrite>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.mode =
            std::option::Option::Some(crate::model::transaction_options::Mode::ReadWrite(v.into()));
        self
    }

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

    /// Sets the value of [mode][crate::model::TransactionOptions::mode]
    /// to hold a `PartitionedDml`.
    ///
    /// Note that all the setters affecting `mode` are
    /// mutually exclusive.
    pub fn set_partitioned_dml<
        T: std::convert::Into<std::boxed::Box<crate::model::transaction_options::PartitionedDml>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.mode = std::option::Option::Some(
            crate::model::transaction_options::Mode::PartitionedDml(v.into()),
        );
        self
    }

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

    /// Sets the value of [mode][crate::model::TransactionOptions::mode]
    /// to hold a `ReadOnly`.
    ///
    /// Note that all the setters affecting `mode` are
    /// mutually exclusive.
    pub fn set_read_only<
        T: std::convert::Into<std::boxed::Box<crate::model::transaction_options::ReadOnly>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.mode =
            std::option::Option::Some(crate::model::transaction_options::Mode::ReadOnly(v.into()));
        self
    }
}

impl wkt::message::Message for TransactionOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.TransactionOptions"
    }
}

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

    /// Message type to initiate a read-write transaction. Currently this
    /// transaction type has no options.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ReadWrite {
        /// Read lock mode for the transaction.
        pub read_lock_mode: crate::model::transaction_options::read_write::ReadLockMode,

        /// Optional. Clients should pass the transaction ID of the previous
        /// transaction attempt that was aborted if this transaction is being
        /// executed on a multiplexed session.
        pub multiplexed_session_previous_transaction_id: ::bytes::Bytes,

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

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

        /// Sets the value of [read_lock_mode][crate::model::transaction_options::ReadWrite::read_lock_mode].
        pub fn set_read_lock_mode<
            T: std::convert::Into<crate::model::transaction_options::read_write::ReadLockMode>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.read_lock_mode = v.into();
            self
        }

        /// Sets the value of [multiplexed_session_previous_transaction_id][crate::model::transaction_options::ReadWrite::multiplexed_session_previous_transaction_id].
        pub fn set_multiplexed_session_previous_transaction_id<
            T: std::convert::Into<::bytes::Bytes>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.multiplexed_session_previous_transaction_id = v.into();
            self
        }
    }

    impl wkt::message::Message for ReadWrite {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.TransactionOptions.ReadWrite"
        }
    }

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

        /// `ReadLockMode` is used to set the read lock mode for read-write
        /// transactions.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum ReadLockMode {
            /// Default value.
            ///
            /// * If isolation level is
            ///   [SERIALIZABLE][google.spanner.v1.TransactionOptions.IsolationLevel.SERIALIZABLE],
            ///   locking semantics default to `PESSIMISTIC`.
            /// * If isolation level is
            ///   [REPEATABLE_READ][google.spanner.v1.TransactionOptions.IsolationLevel.REPEATABLE_READ],
            ///   locking semantics default to `OPTIMISTIC`.
            /// * See
            ///   [Concurrency
            ///   control](https://cloud.google.com/spanner/docs/concurrency-control)
            ///   for more details.
            ///
            /// [google.spanner.v1.TransactionOptions.IsolationLevel.REPEATABLE_READ]: crate::model::transaction_options::IsolationLevel::RepeatableRead
            /// [google.spanner.v1.TransactionOptions.IsolationLevel.SERIALIZABLE]: crate::model::transaction_options::IsolationLevel::Serializable
            Unspecified,
            /// Pessimistic lock mode.
            ///
            /// Lock acquisition behavior depends on the isolation level in use. In
            /// [SERIALIZABLE][google.spanner.v1.TransactionOptions.IsolationLevel.SERIALIZABLE]
            /// isolation, reads and writes acquire necessary locks during transaction
            /// statement execution. In
            /// [REPEATABLE_READ][google.spanner.v1.TransactionOptions.IsolationLevel.REPEATABLE_READ]
            /// isolation, reads that explicitly request to be locked and writes
            /// acquire locks.
            /// See
            /// [Concurrency
            /// control](https://cloud.google.com/spanner/docs/concurrency-control) for
            /// details on the types of locks acquired at each transaction step.
            ///
            /// [google.spanner.v1.TransactionOptions.IsolationLevel.REPEATABLE_READ]: crate::model::transaction_options::IsolationLevel::RepeatableRead
            /// [google.spanner.v1.TransactionOptions.IsolationLevel.SERIALIZABLE]: crate::model::transaction_options::IsolationLevel::Serializable
            Pessimistic,
            /// Optimistic lock mode.
            ///
            /// Lock acquisition behavior depends on the isolation level in use. In
            /// both
            /// [SERIALIZABLE][google.spanner.v1.TransactionOptions.IsolationLevel.SERIALIZABLE]
            /// and
            /// [REPEATABLE_READ][google.spanner.v1.TransactionOptions.IsolationLevel.REPEATABLE_READ]
            /// isolation, reads and writes do not acquire locks during transaction
            /// statement execution.
            /// See
            /// [Concurrency
            /// control](https://cloud.google.com/spanner/docs/concurrency-control) for
            /// details on how the guarantees of each isolation level are provided at
            /// commit time.
            ///
            /// [google.spanner.v1.TransactionOptions.IsolationLevel.REPEATABLE_READ]: crate::model::transaction_options::IsolationLevel::RepeatableRead
            /// [google.spanner.v1.TransactionOptions.IsolationLevel.SERIALIZABLE]: crate::model::transaction_options::IsolationLevel::Serializable
            Optimistic,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [ReadLockMode::value] or
            /// [ReadLockMode::name].
            UnknownValue(read_lock_mode::UnknownValue),
        }

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

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

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

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

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

        impl std::convert::From<i32> for ReadLockMode {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::Pessimistic,
                    2 => Self::Optimistic,
                    _ => Self::UnknownValue(read_lock_mode::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for ReadLockMode {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "READ_LOCK_MODE_UNSPECIFIED" => Self::Unspecified,
                    "PESSIMISTIC" => Self::Pessimistic,
                    "OPTIMISTIC" => Self::Optimistic,
                    _ => Self::UnknownValue(read_lock_mode::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

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

        impl<'de> serde::de::Deserialize<'de> for ReadLockMode {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<ReadLockMode>::new(
                    ".google.spanner.v1.TransactionOptions.ReadWrite.ReadLockMode",
                ))
            }
        }
    }

    /// Message type to initiate a Partitioned DML transaction.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct PartitionedDml {
        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

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

    impl wkt::message::Message for PartitionedDml {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.TransactionOptions.PartitionedDml"
        }
    }

    /// Message type to initiate a read-only transaction.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ReadOnly {
        /// If true, the Cloud Spanner-selected read timestamp is included in
        /// the [Transaction][google.spanner.v1.Transaction] message that describes
        /// the transaction.
        ///
        /// [google.spanner.v1.Transaction]: crate::model::Transaction
        pub return_read_timestamp: bool,

        /// How to choose the timestamp for the read-only transaction.
        pub timestamp_bound:
            std::option::Option<crate::model::transaction_options::read_only::TimestampBound>,

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

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

        /// Sets the value of [return_read_timestamp][crate::model::transaction_options::ReadOnly::return_read_timestamp].
        pub fn set_return_read_timestamp<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.return_read_timestamp = v.into();
            self
        }

        /// Sets the value of [timestamp_bound][crate::model::transaction_options::ReadOnly::timestamp_bound].
        ///
        /// Note that all the setters affecting `timestamp_bound` are mutually
        /// exclusive.
        pub fn set_timestamp_bound<
            T: std::convert::Into<
                    std::option::Option<
                        crate::model::transaction_options::read_only::TimestampBound,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.timestamp_bound = v.into();
            self
        }

        /// The value of [timestamp_bound][crate::model::transaction_options::ReadOnly::timestamp_bound]
        /// if it holds a `Strong`, `None` if the field is not set or
        /// holds a different branch.
        pub fn strong(&self) -> std::option::Option<&bool> {
            #[allow(unreachable_patterns)]
            self.timestamp_bound.as_ref().and_then(|v| match v {
                crate::model::transaction_options::read_only::TimestampBound::Strong(v) => {
                    std::option::Option::Some(v)
                }
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [timestamp_bound][crate::model::transaction_options::ReadOnly::timestamp_bound]
        /// to hold a `Strong`.
        ///
        /// Note that all the setters affecting `timestamp_bound` are
        /// mutually exclusive.
        pub fn set_strong<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.timestamp_bound = std::option::Option::Some(
                crate::model::transaction_options::read_only::TimestampBound::Strong(v.into()),
            );
            self
        }

        /// The value of [timestamp_bound][crate::model::transaction_options::ReadOnly::timestamp_bound]
        /// if it holds a `MinReadTimestamp`, `None` if the field is not set or
        /// holds a different branch.
        pub fn min_read_timestamp(&self) -> std::option::Option<&std::boxed::Box<wkt::Timestamp>> {
            #[allow(unreachable_patterns)]
            self.timestamp_bound.as_ref().and_then(|v| match v {
                crate::model::transaction_options::read_only::TimestampBound::MinReadTimestamp(
                    v,
                ) => std::option::Option::Some(v),
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [timestamp_bound][crate::model::transaction_options::ReadOnly::timestamp_bound]
        /// to hold a `MinReadTimestamp`.
        ///
        /// Note that all the setters affecting `timestamp_bound` are
        /// mutually exclusive.
        pub fn set_min_read_timestamp<T: std::convert::Into<std::boxed::Box<wkt::Timestamp>>>(
            mut self,
            v: T,
        ) -> Self {
            self.timestamp_bound = std::option::Option::Some(
                crate::model::transaction_options::read_only::TimestampBound::MinReadTimestamp(
                    v.into(),
                ),
            );
            self
        }

        /// The value of [timestamp_bound][crate::model::transaction_options::ReadOnly::timestamp_bound]
        /// if it holds a `MaxStaleness`, `None` if the field is not set or
        /// holds a different branch.
        pub fn max_staleness(&self) -> std::option::Option<&std::boxed::Box<wkt::Duration>> {
            #[allow(unreachable_patterns)]
            self.timestamp_bound.as_ref().and_then(|v| match v {
                crate::model::transaction_options::read_only::TimestampBound::MaxStaleness(v) => {
                    std::option::Option::Some(v)
                }
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [timestamp_bound][crate::model::transaction_options::ReadOnly::timestamp_bound]
        /// to hold a `MaxStaleness`.
        ///
        /// Note that all the setters affecting `timestamp_bound` are
        /// mutually exclusive.
        pub fn set_max_staleness<T: std::convert::Into<std::boxed::Box<wkt::Duration>>>(
            mut self,
            v: T,
        ) -> Self {
            self.timestamp_bound = std::option::Option::Some(
                crate::model::transaction_options::read_only::TimestampBound::MaxStaleness(
                    v.into(),
                ),
            );
            self
        }

        /// The value of [timestamp_bound][crate::model::transaction_options::ReadOnly::timestamp_bound]
        /// if it holds a `ReadTimestamp`, `None` if the field is not set or
        /// holds a different branch.
        pub fn read_timestamp(&self) -> std::option::Option<&std::boxed::Box<wkt::Timestamp>> {
            #[allow(unreachable_patterns)]
            self.timestamp_bound.as_ref().and_then(|v| match v {
                crate::model::transaction_options::read_only::TimestampBound::ReadTimestamp(v) => {
                    std::option::Option::Some(v)
                }
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [timestamp_bound][crate::model::transaction_options::ReadOnly::timestamp_bound]
        /// to hold a `ReadTimestamp`.
        ///
        /// Note that all the setters affecting `timestamp_bound` are
        /// mutually exclusive.
        pub fn set_read_timestamp<T: std::convert::Into<std::boxed::Box<wkt::Timestamp>>>(
            mut self,
            v: T,
        ) -> Self {
            self.timestamp_bound = std::option::Option::Some(
                crate::model::transaction_options::read_only::TimestampBound::ReadTimestamp(
                    v.into(),
                ),
            );
            self
        }

        /// The value of [timestamp_bound][crate::model::transaction_options::ReadOnly::timestamp_bound]
        /// if it holds a `ExactStaleness`, `None` if the field is not set or
        /// holds a different branch.
        pub fn exact_staleness(&self) -> std::option::Option<&std::boxed::Box<wkt::Duration>> {
            #[allow(unreachable_patterns)]
            self.timestamp_bound.as_ref().and_then(|v| match v {
                crate::model::transaction_options::read_only::TimestampBound::ExactStaleness(v) => {
                    std::option::Option::Some(v)
                }
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [timestamp_bound][crate::model::transaction_options::ReadOnly::timestamp_bound]
        /// to hold a `ExactStaleness`.
        ///
        /// Note that all the setters affecting `timestamp_bound` are
        /// mutually exclusive.
        pub fn set_exact_staleness<T: std::convert::Into<std::boxed::Box<wkt::Duration>>>(
            mut self,
            v: T,
        ) -> Self {
            self.timestamp_bound = std::option::Option::Some(
                crate::model::transaction_options::read_only::TimestampBound::ExactStaleness(
                    v.into(),
                ),
            );
            self
        }
    }

    impl wkt::message::Message for ReadOnly {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.TransactionOptions.ReadOnly"
        }
    }

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

        /// How to choose the timestamp for the read-only transaction.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum TimestampBound {
            /// Read at a timestamp where all previously committed transactions
            /// are visible.
            Strong(bool),
            /// Executes all reads at a timestamp >= `min_read_timestamp`.
            ///
            /// This is useful for requesting fresher data than some previous
            /// read, or data that is fresh enough to observe the effects of some
            /// previously committed transaction whose timestamp is known.
            ///
            /// Note that this option can only be used in single-use transactions.
            ///
            /// A timestamp in RFC3339 UTC \"Zulu\" format, accurate to nanoseconds.
            /// Example: `"2014-10-02T15:01:23.045123456Z"`.
            MinReadTimestamp(std::boxed::Box<wkt::Timestamp>),
            /// Read data at a timestamp >= `NOW - max_staleness`
            /// seconds. Guarantees that all writes that have committed more
            /// than the specified number of seconds ago are visible. Because
            /// Cloud Spanner chooses the exact timestamp, this mode works even if
            /// the client's local clock is substantially skewed from Cloud Spanner
            /// commit timestamps.
            ///
            /// Useful for reading the freshest data available at a nearby
            /// replica, while bounding the possible staleness if the local
            /// replica has fallen behind.
            ///
            /// Note that this option can only be used in single-use
            /// transactions.
            MaxStaleness(std::boxed::Box<wkt::Duration>),
            /// Executes all reads at the given timestamp. Unlike other modes,
            /// reads at a specific timestamp are repeatable; the same read at
            /// the same timestamp always returns the same data. If the
            /// timestamp is in the future, the read is blocked until the
            /// specified timestamp, modulo the read's deadline.
            ///
            /// Useful for large scale consistent reads such as mapreduces, or
            /// for coordinating many reads against a consistent snapshot of the
            /// data.
            ///
            /// A timestamp in RFC3339 UTC \"Zulu\" format, accurate to nanoseconds.
            /// Example: `"2014-10-02T15:01:23.045123456Z"`.
            ReadTimestamp(std::boxed::Box<wkt::Timestamp>),
            /// Executes all reads at a timestamp that is `exact_staleness`
            /// old. The timestamp is chosen soon after the read is started.
            ///
            /// Guarantees that all writes that have committed more than the
            /// specified number of seconds ago are visible. Because Cloud Spanner
            /// chooses the exact timestamp, this mode works even if the client's
            /// local clock is substantially skewed from Cloud Spanner commit
            /// timestamps.
            ///
            /// Useful for reading at nearby replicas without the distributed
            /// timestamp negotiation overhead of `max_staleness`.
            ExactStaleness(std::boxed::Box<wkt::Duration>),
        }

        impl TimestampBound {
            /// Initializes the enum to the [Strong](Self::Strong) branch.
            pub fn from_strong(value: impl std::convert::Into<bool>) -> Self {
                Self::Strong(value.into())
            }
            /// Initializes the enum to the [MinReadTimestamp](Self::MinReadTimestamp) branch.
            pub fn from_min_read_timestamp(
                value: impl std::convert::Into<std::boxed::Box<wkt::Timestamp>>,
            ) -> Self {
                Self::MinReadTimestamp(value.into())
            }
            /// Initializes the enum to the [MaxStaleness](Self::MaxStaleness) branch.
            pub fn from_max_staleness(
                value: impl std::convert::Into<std::boxed::Box<wkt::Duration>>,
            ) -> Self {
                Self::MaxStaleness(value.into())
            }
            /// Initializes the enum to the [ReadTimestamp](Self::ReadTimestamp) branch.
            pub fn from_read_timestamp(
                value: impl std::convert::Into<std::boxed::Box<wkt::Timestamp>>,
            ) -> Self {
                Self::ReadTimestamp(value.into())
            }
            /// Initializes the enum to the [ExactStaleness](Self::ExactStaleness) branch.
            pub fn from_exact_staleness(
                value: impl std::convert::Into<std::boxed::Box<wkt::Duration>>,
            ) -> Self {
                Self::ExactStaleness(value.into())
            }
        }
    }

    /// `IsolationLevel` is used when setting the [isolation
    /// level](https://cloud.google.com/spanner/docs/isolation-levels) for a
    /// transaction.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum IsolationLevel {
        /// Default value.
        ///
        /// If the value is not specified, the `SERIALIZABLE` isolation level is
        /// used.
        Unspecified,
        /// All transactions appear as if they executed in a serial order, even if
        /// some of the reads, writes, and other operations of distinct transactions
        /// actually occurred in parallel. Spanner assigns commit timestamps that
        /// reflect the order of committed transactions to implement this property.
        /// Spanner offers a stronger guarantee than serializability called external
        /// consistency. For more information, see
        /// [TrueTime and external
        /// consistency](https://cloud.google.com/spanner/docs/true-time-external-consistency#serializability).
        Serializable,
        /// All reads performed during the transaction observe a consistent snapshot
        /// of the database, and the transaction is only successfully committed in
        /// the absence of conflicts between its updates and any concurrent updates
        /// that have occurred since that snapshot. Consequently, in contrast to
        /// `SERIALIZABLE` transactions, only write-write conflicts are detected in
        /// snapshot transactions.
        ///
        /// This isolation level does not support read-only and partitioned DML
        /// transactions.
        ///
        /// When `REPEATABLE_READ` is specified on a read-write transaction, the
        /// locking semantics default to `OPTIMISTIC`.
        RepeatableRead,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [IsolationLevel::value] or
        /// [IsolationLevel::name].
        UnknownValue(isolation_level::UnknownValue),
    }

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

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

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

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

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

    impl std::convert::From<i32> for IsolationLevel {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Serializable,
                2 => Self::RepeatableRead,
                _ => Self::UnknownValue(isolation_level::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for IsolationLevel {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "ISOLATION_LEVEL_UNSPECIFIED" => Self::Unspecified,
                "SERIALIZABLE" => Self::Serializable,
                "REPEATABLE_READ" => Self::RepeatableRead,
                _ => Self::UnknownValue(isolation_level::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

    /// Required. The type of transaction.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Mode {
        /// Transaction may write.
        ///
        /// Authorization to begin a read-write transaction requires
        /// `spanner.databases.beginOrRollbackReadWriteTransaction` permission
        /// on the `session` resource.
        ReadWrite(std::boxed::Box<crate::model::transaction_options::ReadWrite>),
        /// Partitioned DML transaction.
        ///
        /// Authorization to begin a Partitioned DML transaction requires
        /// `spanner.databases.beginPartitionedDmlTransaction` permission
        /// on the `session` resource.
        PartitionedDml(std::boxed::Box<crate::model::transaction_options::PartitionedDml>),
        /// Transaction does not write.
        ///
        /// Authorization to begin a read-only transaction requires
        /// `spanner.databases.beginReadOnlyTransaction` permission
        /// on the `session` resource.
        ReadOnly(std::boxed::Box<crate::model::transaction_options::ReadOnly>),
    }

    impl Mode {
        /// Initializes the enum to the [ReadWrite](Self::ReadWrite) branch.
        pub fn from_read_write(
            value: impl std::convert::Into<
                std::boxed::Box<crate::model::transaction_options::ReadWrite>,
            >,
        ) -> Self {
            Self::ReadWrite(value.into())
        }
        /// Initializes the enum to the [PartitionedDml](Self::PartitionedDml) branch.
        pub fn from_partitioned_dml(
            value: impl std::convert::Into<
                std::boxed::Box<crate::model::transaction_options::PartitionedDml>,
            >,
        ) -> Self {
            Self::PartitionedDml(value.into())
        }
        /// Initializes the enum to the [ReadOnly](Self::ReadOnly) branch.
        pub fn from_read_only(
            value: impl std::convert::Into<std::boxed::Box<crate::model::transaction_options::ReadOnly>>,
        ) -> Self {
            Self::ReadOnly(value.into())
        }
    }
}

/// A transaction.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Transaction {
    /// `id` may be used to identify the transaction in subsequent
    /// [Read][google.spanner.v1.Spanner.Read],
    /// [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql],
    /// [Commit][google.spanner.v1.Spanner.Commit], or
    /// [Rollback][google.spanner.v1.Spanner.Rollback] calls.
    ///
    /// Single-use read-only transactions do not have IDs, because
    /// single-use transactions do not support multiple requests.
    ///
    /// [google.spanner.v1.Spanner.Commit]: crate::client::Spanner::commit
    /// [google.spanner.v1.Spanner.ExecuteSql]: crate::client::Spanner::execute_sql
    /// [google.spanner.v1.Spanner.Read]: crate::client::Spanner::read
    /// [google.spanner.v1.Spanner.Rollback]: crate::client::Spanner::rollback
    pub id: ::bytes::Bytes,

    /// For snapshot read-only transactions, the read timestamp chosen
    /// for the transaction. Not returned by default: see
    /// [TransactionOptions.ReadOnly.return_read_timestamp][google.spanner.v1.TransactionOptions.ReadOnly.return_read_timestamp].
    ///
    /// A timestamp in RFC3339 UTC \"Zulu\" format, accurate to nanoseconds.
    /// Example: `"2014-10-02T15:01:23.045123456Z"`.
    ///
    /// [google.spanner.v1.TransactionOptions.ReadOnly.return_read_timestamp]: crate::model::transaction_options::ReadOnly::return_read_timestamp
    pub read_timestamp: std::option::Option<wkt::Timestamp>,

    /// A precommit token is included in the response of a BeginTransaction
    /// request if the read-write transaction is on a multiplexed session and
    /// a mutation_key was specified in the
    /// [BeginTransaction][google.spanner.v1.BeginTransactionRequest].
    /// The precommit token with the highest sequence number from this transaction
    /// attempt should be passed to the [Commit][google.spanner.v1.Spanner.Commit]
    /// request for this transaction.
    ///
    /// [google.spanner.v1.BeginTransactionRequest]: crate::model::BeginTransactionRequest
    /// [google.spanner.v1.Spanner.Commit]: crate::client::Spanner::commit
    pub precommit_token: std::option::Option<crate::model::MultiplexedSessionPrecommitToken>,

    /// Optional. A cache update expresses a set of changes the client should
    /// incorporate into its location cache. The client should discard the changes
    /// if they are older than the data it already has. This data can be obtained
    /// in response to requests that included a `RoutingHint` field, but may also
    /// be obtained by explicit location-fetching RPCs which may be added in the
    /// future.
    pub cache_update: std::option::Option<crate::model::CacheUpdate>,

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

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

    /// Sets the value of [id][crate::model::Transaction::id].
    pub fn set_id<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.id = v.into();
        self
    }

    /// Sets the value of [read_timestamp][crate::model::Transaction::read_timestamp].
    pub fn set_read_timestamp<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.read_timestamp = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [read_timestamp][crate::model::Transaction::read_timestamp].
    pub fn set_or_clear_read_timestamp<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.read_timestamp = v.map(|x| x.into());
        self
    }

    /// Sets the value of [precommit_token][crate::model::Transaction::precommit_token].
    pub fn set_precommit_token<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MultiplexedSessionPrecommitToken>,
    {
        self.precommit_token = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [precommit_token][crate::model::Transaction::precommit_token].
    pub fn set_or_clear_precommit_token<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MultiplexedSessionPrecommitToken>,
    {
        self.precommit_token = v.map(|x| x.into());
        self
    }

    /// Sets the value of [cache_update][crate::model::Transaction::cache_update].
    pub fn set_cache_update<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::CacheUpdate>,
    {
        self.cache_update = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [cache_update][crate::model::Transaction::cache_update].
    pub fn set_or_clear_cache_update<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::CacheUpdate>,
    {
        self.cache_update = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for Transaction {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.Transaction"
    }
}

/// This message is used to select the transaction in which a
/// [Read][google.spanner.v1.Spanner.Read] or
/// [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql] call runs.
///
/// See [TransactionOptions][google.spanner.v1.TransactionOptions] for more
/// information about transactions.
///
/// [google.spanner.v1.Spanner.ExecuteSql]: crate::client::Spanner::execute_sql
/// [google.spanner.v1.Spanner.Read]: crate::client::Spanner::read
/// [google.spanner.v1.TransactionOptions]: crate::model::TransactionOptions
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TransactionSelector {
    /// If no fields are set, the default is a single use transaction
    /// with strong concurrency.
    pub selector: std::option::Option<crate::model::transaction_selector::Selector>,

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

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

    /// Sets the value of [selector][crate::model::TransactionSelector::selector].
    ///
    /// Note that all the setters affecting `selector` are mutually
    /// exclusive.
    pub fn set_selector<
        T: std::convert::Into<std::option::Option<crate::model::transaction_selector::Selector>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.selector = v.into();
        self
    }

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

    /// Sets the value of [selector][crate::model::TransactionSelector::selector]
    /// to hold a `SingleUse`.
    ///
    /// Note that all the setters affecting `selector` are
    /// mutually exclusive.
    pub fn set_single_use<
        T: std::convert::Into<std::boxed::Box<crate::model::TransactionOptions>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.selector = std::option::Option::Some(
            crate::model::transaction_selector::Selector::SingleUse(v.into()),
        );
        self
    }

    /// The value of [selector][crate::model::TransactionSelector::selector]
    /// if it holds a `Id`, `None` if the field is not set or
    /// holds a different branch.
    pub fn id(&self) -> std::option::Option<&::bytes::Bytes> {
        #[allow(unreachable_patterns)]
        self.selector.as_ref().and_then(|v| match v {
            crate::model::transaction_selector::Selector::Id(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [selector][crate::model::TransactionSelector::selector]
    /// to hold a `Id`.
    ///
    /// Note that all the setters affecting `selector` are
    /// mutually exclusive.
    pub fn set_id<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.selector =
            std::option::Option::Some(crate::model::transaction_selector::Selector::Id(v.into()));
        self
    }

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

    /// Sets the value of [selector][crate::model::TransactionSelector::selector]
    /// to hold a `Begin`.
    ///
    /// Note that all the setters affecting `selector` are
    /// mutually exclusive.
    pub fn set_begin<T: std::convert::Into<std::boxed::Box<crate::model::TransactionOptions>>>(
        mut self,
        v: T,
    ) -> Self {
        self.selector = std::option::Option::Some(
            crate::model::transaction_selector::Selector::Begin(v.into()),
        );
        self
    }
}

impl wkt::message::Message for TransactionSelector {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.TransactionSelector"
    }
}

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

    /// If no fields are set, the default is a single use transaction
    /// with strong concurrency.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Selector {
        /// Execute the read or SQL query in a temporary transaction.
        /// This is the most efficient way to execute a transaction that
        /// consists of a single SQL query.
        SingleUse(std::boxed::Box<crate::model::TransactionOptions>),
        /// Execute the read or SQL query in a previously-started transaction.
        Id(::bytes::Bytes),
        /// Begin a new transaction and execute this read or SQL query in
        /// it. The transaction ID of the new transaction is returned in
        /// [ResultSetMetadata.transaction][google.spanner.v1.ResultSetMetadata.transaction],
        /// which is a [Transaction][google.spanner.v1.Transaction].
        ///
        /// [google.spanner.v1.ResultSetMetadata.transaction]: crate::model::ResultSetMetadata::transaction
        /// [google.spanner.v1.Transaction]: crate::model::Transaction
        Begin(std::boxed::Box<crate::model::TransactionOptions>),
    }

    impl Selector {
        /// Initializes the enum to the [SingleUse](Self::SingleUse) branch.
        pub fn from_single_use(
            value: impl std::convert::Into<std::boxed::Box<crate::model::TransactionOptions>>,
        ) -> Self {
            Self::SingleUse(value.into())
        }
        /// Initializes the enum to the [Id](Self::Id) branch.
        pub fn from_id(value: impl std::convert::Into<::bytes::Bytes>) -> Self {
            Self::Id(value.into())
        }
        /// Initializes the enum to the [Begin](Self::Begin) branch.
        pub fn from_begin(
            value: impl std::convert::Into<std::boxed::Box<crate::model::TransactionOptions>>,
        ) -> Self {
            Self::Begin(value.into())
        }
    }
}

/// When a read-write transaction is executed on a multiplexed session,
/// this precommit token is sent back to the client
/// as a part of the [Transaction][google.spanner.v1.Transaction] message in the
/// [BeginTransaction][google.spanner.v1.BeginTransactionRequest] response and
/// also as a part of the [ResultSet][google.spanner.v1.ResultSet] and
/// [PartialResultSet][google.spanner.v1.PartialResultSet] responses.
///
/// [google.spanner.v1.BeginTransactionRequest]: crate::model::BeginTransactionRequest
/// [google.spanner.v1.PartialResultSet]: crate::model::PartialResultSet
/// [google.spanner.v1.ResultSet]: crate::model::ResultSet
/// [google.spanner.v1.Transaction]: crate::model::Transaction
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MultiplexedSessionPrecommitToken {
    /// Opaque precommit token.
    pub precommit_token: ::bytes::Bytes,

    /// An incrementing seq number is generated on every precommit token
    /// that is returned. Clients should remember the precommit token with the
    /// highest sequence number from the current transaction attempt.
    pub seq_num: i32,

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

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

    /// Sets the value of [precommit_token][crate::model::MultiplexedSessionPrecommitToken::precommit_token].
    pub fn set_precommit_token<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.precommit_token = v.into();
        self
    }

    /// Sets the value of [seq_num][crate::model::MultiplexedSessionPrecommitToken::seq_num].
    pub fn set_seq_num<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.seq_num = v.into();
        self
    }
}

impl wkt::message::Message for MultiplexedSessionPrecommitToken {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.MultiplexedSessionPrecommitToken"
    }
}

/// `Type` indicates the type of a Cloud Spanner value, as might be stored in a
/// table cell or returned from an SQL query.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Type {
    /// Required. The [TypeCode][google.spanner.v1.TypeCode] for this type.
    ///
    /// [google.spanner.v1.TypeCode]: crate::model::TypeCode
    pub code: crate::model::TypeCode,

    /// If [code][google.spanner.v1.Type.code] ==
    /// [ARRAY][google.spanner.v1.TypeCode.ARRAY], then `array_element_type` is the
    /// type of the array elements.
    ///
    /// [google.spanner.v1.Type.code]: crate::model::Type::code
    /// [google.spanner.v1.TypeCode.ARRAY]: crate::model::TypeCode::Array
    pub array_element_type: std::option::Option<std::boxed::Box<crate::model::Type>>,

    /// If [code][google.spanner.v1.Type.code] ==
    /// [STRUCT][google.spanner.v1.TypeCode.STRUCT], then `struct_type` provides
    /// type information for the struct's fields.
    ///
    /// [google.spanner.v1.Type.code]: crate::model::Type::code
    /// [google.spanner.v1.TypeCode.STRUCT]: crate::model::TypeCode::Struct
    pub struct_type: std::option::Option<std::boxed::Box<crate::model::StructType>>,

    /// The [TypeAnnotationCode][google.spanner.v1.TypeAnnotationCode] that
    /// disambiguates SQL type that Spanner will use to represent values of this
    /// type during query processing. This is necessary for some type codes because
    /// a single [TypeCode][google.spanner.v1.TypeCode] can be mapped to different
    /// SQL types depending on the SQL dialect.
    /// [type_annotation][google.spanner.v1.Type.type_annotation] typically is not
    /// needed to process the content of a value (it doesn't affect serialization)
    /// and clients can ignore it on the read path.
    ///
    /// [google.spanner.v1.Type.type_annotation]: crate::model::Type::type_annotation
    /// [google.spanner.v1.TypeAnnotationCode]: crate::model::TypeAnnotationCode
    /// [google.spanner.v1.TypeCode]: crate::model::TypeCode
    pub type_annotation: crate::model::TypeAnnotationCode,

    /// If [code][google.spanner.v1.Type.code] ==
    /// [PROTO][google.spanner.v1.TypeCode.PROTO] or
    /// [code][google.spanner.v1.Type.code] ==
    /// [ENUM][google.spanner.v1.TypeCode.ENUM], then `proto_type_fqn` is the fully
    /// qualified name of the proto type representing the proto/enum definition.
    ///
    /// [google.spanner.v1.Type.code]: crate::model::Type::code
    /// [google.spanner.v1.TypeCode.ENUM]: crate::model::TypeCode::Enum
    /// [google.spanner.v1.TypeCode.PROTO]: crate::model::TypeCode::Proto
    pub proto_type_fqn: std::string::String,

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

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

    /// Sets the value of [code][crate::model::Type::code].
    pub fn set_code<T: std::convert::Into<crate::model::TypeCode>>(mut self, v: T) -> Self {
        self.code = v.into();
        self
    }

    /// Sets the value of [array_element_type][crate::model::Type::array_element_type].
    pub fn set_array_element_type<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Type>,
    {
        self.array_element_type = std::option::Option::Some(std::boxed::Box::new(v.into()));
        self
    }

    /// Sets or clears the value of [array_element_type][crate::model::Type::array_element_type].
    pub fn set_or_clear_array_element_type<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Type>,
    {
        self.array_element_type = v.map(|x| std::boxed::Box::new(x.into()));
        self
    }

    /// Sets the value of [struct_type][crate::model::Type::struct_type].
    pub fn set_struct_type<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::StructType>,
    {
        self.struct_type = std::option::Option::Some(std::boxed::Box::new(v.into()));
        self
    }

    /// Sets or clears the value of [struct_type][crate::model::Type::struct_type].
    pub fn set_or_clear_struct_type<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::StructType>,
    {
        self.struct_type = v.map(|x| std::boxed::Box::new(x.into()));
        self
    }

    /// Sets the value of [type_annotation][crate::model::Type::type_annotation].
    pub fn set_type_annotation<T: std::convert::Into<crate::model::TypeAnnotationCode>>(
        mut self,
        v: T,
    ) -> Self {
        self.type_annotation = v.into();
        self
    }

    /// Sets the value of [proto_type_fqn][crate::model::Type::proto_type_fqn].
    pub fn set_proto_type_fqn<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.proto_type_fqn = v.into();
        self
    }
}

impl wkt::message::Message for Type {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.Type"
    }
}

/// `StructType` defines the fields of a
/// [STRUCT][google.spanner.v1.TypeCode.STRUCT] type.
///
/// [google.spanner.v1.TypeCode.STRUCT]: crate::model::TypeCode::Struct
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StructType {
    /// The list of fields that make up this struct. Order is
    /// significant, because values of this struct type are represented as
    /// lists, where the order of field values matches the order of
    /// fields in the [StructType][google.spanner.v1.StructType]. In turn, the
    /// order of fields matches the order of columns in a read request, or the
    /// order of fields in the `SELECT` clause of a query.
    ///
    /// [google.spanner.v1.StructType]: crate::model::StructType
    pub fields: std::vec::Vec<crate::model::struct_type::Field>,

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

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

    /// Sets the value of [fields][crate::model::StructType::fields].
    pub fn set_fields<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::struct_type::Field>,
    {
        use std::iter::Iterator;
        self.fields = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for StructType {
    fn typename() -> &'static str {
        "type.googleapis.com/google.spanner.v1.StructType"
    }
}

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

    /// Message representing a single field of a struct.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Field {
        /// The name of the field. For reads, this is the column name. For
        /// SQL queries, it is the column alias (e.g., `"Word"` in the
        /// query `"SELECT 'hello' AS Word"`), or the column name (e.g.,
        /// `"ColName"` in the query `"SELECT ColName FROM Table"`). Some
        /// columns might have an empty name (e.g., `"SELECT
        /// UPPER(ColName)"`). Note that a query result can contain
        /// multiple fields with the same name.
        pub name: std::string::String,

        /// The type of the field.
        pub r#type: std::option::Option<std::boxed::Box<crate::model::Type>>,

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

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

        /// Sets the value of [name][crate::model::struct_type::Field::name].
        pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.name = v.into();
            self
        }

        /// Sets the value of [r#type][crate::model::struct_type::Field::type].
        pub fn set_type<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::Type>,
        {
            self.r#type = std::option::Option::Some(std::boxed::Box::new(v.into()));
            self
        }

        /// Sets or clears the value of [r#type][crate::model::struct_type::Field::type].
        pub fn set_or_clear_type<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::Type>,
        {
            self.r#type = v.map(|x| std::boxed::Box::new(x.into()));
            self
        }
    }

    impl wkt::message::Message for Field {
        fn typename() -> &'static str {
            "type.googleapis.com/google.spanner.v1.StructType.Field"
        }
    }
}

/// `TypeCode` is used as part of [Type][google.spanner.v1.Type] to
/// indicate the type of a Cloud Spanner value.
///
/// Each legal value of a type can be encoded to or decoded from a JSON
/// value, using the encodings described below. All Cloud Spanner values can
/// be `null`, regardless of type; `null`s are always encoded as a JSON
/// `null`.
///
/// [google.spanner.v1.Type]: crate::model::Type
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum TypeCode {
    /// Not specified.
    Unspecified,
    /// Encoded as JSON `true` or `false`.
    Bool,
    /// Encoded as `string`, in decimal format.
    Int64,
    /// Encoded as `number`, or the strings `"NaN"`, `"Infinity"`, or
    /// `"-Infinity"`.
    Float64,
    /// Encoded as `number`, or the strings `"NaN"`, `"Infinity"`, or
    /// `"-Infinity"`.
    Float32,
    /// Encoded as `string` in RFC 3339 timestamp format. The time zone
    /// must be present, and must be `"Z"`.
    ///
    /// If the schema has the column option
    /// `allow_commit_timestamp=true`, the placeholder string
    /// `"spanner.commit_timestamp()"` can be used to instruct the system
    /// to insert the commit timestamp associated with the transaction
    /// commit.
    Timestamp,
    /// Encoded as `string` in RFC 3339 date format.
    Date,
    /// Encoded as `string`.
    String,
    /// Encoded as a base64-encoded `string`, as described in RFC 4648,
    /// section 4.
    Bytes,
    /// Encoded as `list`, where the list elements are represented
    /// according to
    /// [array_element_type][google.spanner.v1.Type.array_element_type].
    ///
    /// [google.spanner.v1.Type.array_element_type]: crate::model::Type::array_element_type
    Array,
    /// Encoded as `list`, where list element `i` is represented according
    /// to [struct_type.fields[i]][google.spanner.v1.StructType.fields].
    ///
    /// [google.spanner.v1.StructType.fields]: crate::model::StructType::fields
    Struct,
    /// Encoded as `string`, in decimal format or scientific notation format.
    /// Decimal format:
    /// `[+-]Digits[.[Digits]]` or
    /// `[+-][Digits].Digits`
    ///
    /// Scientific notation:
    /// `[+-]Digits[.[Digits]][ExponentIndicator[+-]Digits]` or
    /// `[+-][Digits].Digits[ExponentIndicator[+-]Digits]`
    /// (ExponentIndicator is `"e"` or `"E"`)
    Numeric,
    /// Encoded as a JSON-formatted `string` as described in RFC 7159. The
    /// following rules are applied when parsing JSON input:
    ///
    /// - Whitespace characters are not preserved.
    /// - If a JSON object has duplicate keys, only the first key is preserved.
    /// - Members of a JSON object are not guaranteed to have their order
    ///   preserved.
    /// - JSON array elements will have their order preserved.
    Json,
    /// Encoded as a base64-encoded `string`, as described in RFC 4648,
    /// section 4.
    Proto,
    /// Encoded as `string`, in decimal format.
    Enum,
    /// Encoded as `string`, in `ISO8601` duration format -
    /// `P[n]Y[n]M[n]DT[n]H[n]M[n[.fraction]]S`
    /// where `n` is an integer.
    /// For example, `P1Y2M3DT4H5M6.5S` represents time duration of 1 year, 2
    /// months, 3 days, 4 hours, 5 minutes, and 6.5 seconds.
    Interval,
    /// Encoded as `string`, in lower-case hexa-decimal format, as described
    /// in RFC 9562, section 4.
    Uuid,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [TypeCode::value] or
    /// [TypeCode::name].
    UnknownValue(type_code::UnknownValue),
}

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

impl TypeCode {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::Bool => std::option::Option::Some(1),
            Self::Int64 => std::option::Option::Some(2),
            Self::Float64 => std::option::Option::Some(3),
            Self::Float32 => std::option::Option::Some(15),
            Self::Timestamp => std::option::Option::Some(4),
            Self::Date => std::option::Option::Some(5),
            Self::String => std::option::Option::Some(6),
            Self::Bytes => std::option::Option::Some(7),
            Self::Array => std::option::Option::Some(8),
            Self::Struct => std::option::Option::Some(9),
            Self::Numeric => std::option::Option::Some(10),
            Self::Json => std::option::Option::Some(11),
            Self::Proto => std::option::Option::Some(13),
            Self::Enum => std::option::Option::Some(14),
            Self::Interval => std::option::Option::Some(16),
            Self::Uuid => std::option::Option::Some(17),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("TYPE_CODE_UNSPECIFIED"),
            Self::Bool => std::option::Option::Some("BOOL"),
            Self::Int64 => std::option::Option::Some("INT64"),
            Self::Float64 => std::option::Option::Some("FLOAT64"),
            Self::Float32 => std::option::Option::Some("FLOAT32"),
            Self::Timestamp => std::option::Option::Some("TIMESTAMP"),
            Self::Date => std::option::Option::Some("DATE"),
            Self::String => std::option::Option::Some("STRING"),
            Self::Bytes => std::option::Option::Some("BYTES"),
            Self::Array => std::option::Option::Some("ARRAY"),
            Self::Struct => std::option::Option::Some("STRUCT"),
            Self::Numeric => std::option::Option::Some("NUMERIC"),
            Self::Json => std::option::Option::Some("JSON"),
            Self::Proto => std::option::Option::Some("PROTO"),
            Self::Enum => std::option::Option::Some("ENUM"),
            Self::Interval => std::option::Option::Some("INTERVAL"),
            Self::Uuid => std::option::Option::Some("UUID"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

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

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

impl std::convert::From<i32> for TypeCode {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::Bool,
            2 => Self::Int64,
            3 => Self::Float64,
            4 => Self::Timestamp,
            5 => Self::Date,
            6 => Self::String,
            7 => Self::Bytes,
            8 => Self::Array,
            9 => Self::Struct,
            10 => Self::Numeric,
            11 => Self::Json,
            13 => Self::Proto,
            14 => Self::Enum,
            15 => Self::Float32,
            16 => Self::Interval,
            17 => Self::Uuid,
            _ => Self::UnknownValue(type_code::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for TypeCode {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "TYPE_CODE_UNSPECIFIED" => Self::Unspecified,
            "BOOL" => Self::Bool,
            "INT64" => Self::Int64,
            "FLOAT64" => Self::Float64,
            "FLOAT32" => Self::Float32,
            "TIMESTAMP" => Self::Timestamp,
            "DATE" => Self::Date,
            "STRING" => Self::String,
            "BYTES" => Self::Bytes,
            "ARRAY" => Self::Array,
            "STRUCT" => Self::Struct,
            "NUMERIC" => Self::Numeric,
            "JSON" => Self::Json,
            "PROTO" => Self::Proto,
            "ENUM" => Self::Enum,
            "INTERVAL" => Self::Interval,
            "UUID" => Self::Uuid,
            _ => Self::UnknownValue(type_code::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for TypeCode {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::Bool => serializer.serialize_i32(1),
            Self::Int64 => serializer.serialize_i32(2),
            Self::Float64 => serializer.serialize_i32(3),
            Self::Float32 => serializer.serialize_i32(15),
            Self::Timestamp => serializer.serialize_i32(4),
            Self::Date => serializer.serialize_i32(5),
            Self::String => serializer.serialize_i32(6),
            Self::Bytes => serializer.serialize_i32(7),
            Self::Array => serializer.serialize_i32(8),
            Self::Struct => serializer.serialize_i32(9),
            Self::Numeric => serializer.serialize_i32(10),
            Self::Json => serializer.serialize_i32(11),
            Self::Proto => serializer.serialize_i32(13),
            Self::Enum => serializer.serialize_i32(14),
            Self::Interval => serializer.serialize_i32(16),
            Self::Uuid => serializer.serialize_i32(17),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

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

/// `TypeAnnotationCode` is used as a part of [Type][google.spanner.v1.Type] to
/// disambiguate SQL types that should be used for a given Cloud Spanner value.
/// Disambiguation is needed because the same Cloud Spanner type can be mapped to
/// different SQL types depending on SQL dialect. TypeAnnotationCode doesn't
/// affect the way value is serialized.
///
/// [google.spanner.v1.Type]: crate::model::Type
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum TypeAnnotationCode {
    /// Not specified.
    Unspecified,
    /// PostgreSQL compatible NUMERIC type. This annotation needs to be applied to
    /// [Type][google.spanner.v1.Type] instances having
    /// [NUMERIC][google.spanner.v1.TypeCode.NUMERIC] type code to specify that
    /// values of this type should be treated as PostgreSQL NUMERIC values.
    /// Currently this annotation is always needed for
    /// [NUMERIC][google.spanner.v1.TypeCode.NUMERIC] when a client interacts with
    /// PostgreSQL-enabled Spanner databases.
    ///
    /// [google.spanner.v1.Type]: crate::model::Type
    /// [google.spanner.v1.TypeCode.NUMERIC]: crate::model::TypeCode::Numeric
    PgNumeric,
    /// PostgreSQL compatible JSONB type. This annotation needs to be applied to
    /// [Type][google.spanner.v1.Type] instances having
    /// [JSON][google.spanner.v1.TypeCode.JSON] type code to specify that values of
    /// this type should be treated as PostgreSQL JSONB values. Currently this
    /// annotation is always needed for [JSON][google.spanner.v1.TypeCode.JSON]
    /// when a client interacts with PostgreSQL-enabled Spanner databases.
    ///
    /// [google.spanner.v1.Type]: crate::model::Type
    /// [google.spanner.v1.TypeCode.JSON]: crate::model::TypeCode::Json
    PgJsonb,
    /// PostgreSQL compatible OID type. This annotation can be used by a client
    /// interacting with PostgreSQL-enabled Spanner database to specify that a
    /// value should be treated using the semantics of the OID type.
    PgOid,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [TypeAnnotationCode::value] or
    /// [TypeAnnotationCode::name].
    UnknownValue(type_annotation_code::UnknownValue),
}

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

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

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

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

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

impl std::convert::From<i32> for TypeAnnotationCode {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            2 => Self::PgNumeric,
            3 => Self::PgJsonb,
            4 => Self::PgOid,
            _ => Self::UnknownValue(type_annotation_code::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for TypeAnnotationCode {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "TYPE_ANNOTATION_CODE_UNSPECIFIED" => Self::Unspecified,
            "PG_NUMERIC" => Self::PgNumeric,
            "PG_JSONB" => Self::PgJsonb,
            "PG_OID" => Self::PgOid,
            _ => Self::UnknownValue(type_annotation_code::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for TypeAnnotationCode {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::PgNumeric => serializer.serialize_i32(2),
            Self::PgJsonb => serializer.serialize_i32(3),
            Self::PgOid => serializer.serialize_i32(4),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

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