google_cloud_bigquery/write/generated/gapic_storage/

model.rs

// 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::bare_urls)]
#![allow(rustdoc::broken_intra_doc_links)]
#![allow(rustdoc::invalid_html_tags)]
#![allow(rustdoc::redundant_explicit_links)]

mod debug;
mod deserialize;
mod serialize;

/// Arrow schema as specified in
/// <https://arrow.apache.org/docs/python/api/datatypes.html>
/// and serialized to bytes using IPC:
/// <https://arrow.apache.org/docs/format/Columnar.html#serialization-and-interprocess-communication-ipc>
///
/// See code samples on how this message can be deserialized.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ArrowSchema {
    /// IPC serialized Arrow schema.
    pub serialized_schema: ::bytes::Bytes,

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

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

    /// Sets the value of [serialized_schema][crate::write::generated::gapic_storage::model::ArrowSchema::serialized_schema].
    pub fn set_serialized_schema<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.serialized_schema = v.into();
        self
    }
}

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

/// Arrow RecordBatch.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ArrowRecordBatch {
    /// IPC-serialized Arrow RecordBatch.
    pub serialized_record_batch: ::bytes::Bytes,

    /// [Deprecated] The count of rows in `serialized_record_batch`.
    /// Please use the format-independent ReadRowsResponse.row_count instead.
    #[deprecated]
    pub row_count: i64,

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

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

    /// Sets the value of [serialized_record_batch][crate::write::generated::gapic_storage::model::ArrowRecordBatch::serialized_record_batch].
    pub fn set_serialized_record_batch<T: std::convert::Into<::bytes::Bytes>>(
        mut self,
        v: T,
    ) -> Self {
        self.serialized_record_batch = v.into();
        self
    }

    /// Sets the value of [row_count][crate::write::generated::gapic_storage::model::ArrowRecordBatch::row_count].
    #[deprecated]
    pub fn set_row_count<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.row_count = v.into();
        self
    }
}

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

/// Contains options specific to Arrow Serialization.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ArrowSerializationOptions {

    /// The compression codec to use for Arrow buffers in serialized record
    /// batches.
    pub buffer_compression: crate::write::generated::gapic_storage::model::arrow_serialization_options::CompressionCodec,

    /// Optional. Set timestamp precision option. If not set, the default precision
    /// is microseconds.
    pub picos_timestamp_precision: crate::write::generated::gapic_storage::model::arrow_serialization_options::PicosTimestampPrecision,

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

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

    /// Sets the value of [buffer_compression][crate::write::generated::gapic_storage::model::ArrowSerializationOptions::buffer_compression].
    pub fn set_buffer_compression<T: std::convert::Into<crate::write::generated::gapic_storage::model::arrow_serialization_options::CompressionCodec>>(mut self, v: T) -> Self{
        self.buffer_compression = v.into();
        self
    }

    /// Sets the value of [picos_timestamp_precision][crate::write::generated::gapic_storage::model::ArrowSerializationOptions::picos_timestamp_precision].
    pub fn set_picos_timestamp_precision<T: std::convert::Into<crate::write::generated::gapic_storage::model::arrow_serialization_options::PicosTimestampPrecision>>(mut self, v: T) -> Self{
        self.picos_timestamp_precision = v.into();
        self
    }
}

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

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

    /// Compression codec's supported by Arrow.
    ///
    /// # 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 CompressionCodec {
        /// If unspecified no compression will be used.
        CompressionUnspecified,
        /// LZ4 Frame (<https://github.com/lz4/lz4/blob/dev/doc/lz4_Frame_format.md>)
        Lz4Frame,
        /// Zstandard compression.
        Zstd,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [CompressionCodec::value] or
        /// [CompressionCodec::name].
        UnknownValue(compression_codec::UnknownValue),
    }

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

    impl CompressionCodec {
        /// 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::CompressionUnspecified => std::option::Option::Some(0),
                Self::Lz4Frame => std::option::Option::Some(1),
                Self::Zstd => 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::CompressionUnspecified => {
                    std::option::Option::Some("COMPRESSION_UNSPECIFIED")
                }
                Self::Lz4Frame => std::option::Option::Some("LZ4_FRAME"),
                Self::Zstd => std::option::Option::Some("ZSTD"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

    impl std::fmt::Display for CompressionCodec {
        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 CompressionCodec {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::CompressionUnspecified,
                1 => Self::Lz4Frame,
                2 => Self::Zstd,
                _ => Self::UnknownValue(compression_codec::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for CompressionCodec {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "COMPRESSION_UNSPECIFIED" => Self::CompressionUnspecified,
                "LZ4_FRAME" => Self::Lz4Frame,
                "ZSTD" => Self::Zstd,
                _ => Self::UnknownValue(compression_codec::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

    /// The precision of the timestamp value in the Avro message. This precision
    /// will **only** be applied to the column(s) with the `TIMESTAMP_PICOS` 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 PicosTimestampPrecision {
        /// Unspecified timestamp precision. The default precision is microseconds.
        Unspecified,
        /// Timestamp values returned by Read API will be truncated to microsecond
        /// level precision. The value will be encoded as Arrow TIMESTAMP type in a
        /// 64 bit integer.
        TimestampPrecisionMicros,
        /// Timestamp values returned by Read API will be truncated to nanosecond
        /// level precision. The value will be encoded as Arrow TIMESTAMP type in a
        /// 64 bit integer.
        TimestampPrecisionNanos,
        /// Read API will return full precision picosecond value. The value will be
        /// encoded as a string which conforms to ISO 8601 format.
        TimestampPrecisionPicos,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [PicosTimestampPrecision::value] or
        /// [PicosTimestampPrecision::name].
        UnknownValue(picos_timestamp_precision::UnknownValue),
    }

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

    impl PicosTimestampPrecision {
        /// 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::TimestampPrecisionMicros => std::option::Option::Some(1),
                Self::TimestampPrecisionNanos => std::option::Option::Some(2),
                Self::TimestampPrecisionPicos => 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("PICOS_TIMESTAMP_PRECISION_UNSPECIFIED")
                }
                Self::TimestampPrecisionMicros => {
                    std::option::Option::Some("TIMESTAMP_PRECISION_MICROS")
                }
                Self::TimestampPrecisionNanos => {
                    std::option::Option::Some("TIMESTAMP_PRECISION_NANOS")
                }
                Self::TimestampPrecisionPicos => {
                    std::option::Option::Some("TIMESTAMP_PRECISION_PICOS")
                }
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

    impl std::fmt::Display for PicosTimestampPrecision {
        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 PicosTimestampPrecision {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::TimestampPrecisionMicros,
                2 => Self::TimestampPrecisionNanos,
                3 => Self::TimestampPrecisionPicos,
                _ => Self::UnknownValue(picos_timestamp_precision::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for PicosTimestampPrecision {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "PICOS_TIMESTAMP_PRECISION_UNSPECIFIED" => Self::Unspecified,
                "TIMESTAMP_PRECISION_MICROS" => Self::TimestampPrecisionMicros,
                "TIMESTAMP_PRECISION_NANOS" => Self::TimestampPrecisionNanos,
                "TIMESTAMP_PRECISION_PICOS" => Self::TimestampPrecisionPicos,
                _ => Self::UnknownValue(picos_timestamp_precision::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for PicosTimestampPrecision {
        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::TimestampPrecisionMicros => serializer.serialize_i32(1),
                Self::TimestampPrecisionNanos => serializer.serialize_i32(2),
                Self::TimestampPrecisionPicos => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// Avro schema.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AvroSchema {
    /// Json serialized schema, as described at
    /// <https://avro.apache.org/docs/1.8.1/spec.html>.
    pub schema: std::string::String,

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

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

    /// Sets the value of [schema][crate::write::generated::gapic_storage::model::AvroSchema::schema].
    pub fn set_schema<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.schema = v.into();
        self
    }
}

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

/// Avro rows.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AvroRows {
    /// Binary serialized rows in a block.
    pub serialized_binary_rows: ::bytes::Bytes,

    /// [Deprecated] The count of rows in the returning block.
    /// Please use the format-independent ReadRowsResponse.row_count instead.
    #[deprecated]
    pub row_count: i64,

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

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

    /// Sets the value of [serialized_binary_rows][crate::write::generated::gapic_storage::model::AvroRows::serialized_binary_rows].
    pub fn set_serialized_binary_rows<T: std::convert::Into<::bytes::Bytes>>(
        mut self,
        v: T,
    ) -> Self {
        self.serialized_binary_rows = v.into();
        self
    }

    /// Sets the value of [row_count][crate::write::generated::gapic_storage::model::AvroRows::row_count].
    #[deprecated]
    pub fn set_row_count<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.row_count = v.into();
        self
    }
}

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

/// Contains options specific to Avro Serialization.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AvroSerializationOptions {

    /// Enable displayName attribute in Avro schema.
    ///
    /// The Avro specification requires field names to be alphanumeric.  By
    /// default, in cases when column names do not conform to these requirements
    /// (e.g. non-ascii unicode codepoints) and Avro is requested as an output
    /// format, the CreateReadSession call will fail.
    ///
    /// Setting this field to true, populates avro field names with a placeholder
    /// value and populates a "displayName" attribute for every avro field with the
    /// original column name.
    pub enable_display_name_attribute: bool,

    /// Optional. Set timestamp precision option. If not set, the default precision
    /// is microseconds.
    pub picos_timestamp_precision: crate::write::generated::gapic_storage::model::avro_serialization_options::PicosTimestampPrecision,

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

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

    /// Sets the value of [enable_display_name_attribute][crate::write::generated::gapic_storage::model::AvroSerializationOptions::enable_display_name_attribute].
    pub fn set_enable_display_name_attribute<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_display_name_attribute = v.into();
        self
    }

    /// Sets the value of [picos_timestamp_precision][crate::write::generated::gapic_storage::model::AvroSerializationOptions::picos_timestamp_precision].
    pub fn set_picos_timestamp_precision<T: std::convert::Into<crate::write::generated::gapic_storage::model::avro_serialization_options::PicosTimestampPrecision>>(mut self, v: T) -> Self{
        self.picos_timestamp_precision = v.into();
        self
    }
}

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

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

    /// The precision of the timestamp value in the Avro message. This precision
    /// will **only** be applied to the column(s) with the `TIMESTAMP_PICOS` 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 PicosTimestampPrecision {
        /// Unspecified timestamp precision. The default precision is microseconds.
        Unspecified,
        /// Timestamp values returned by Read API will be truncated to microsecond
        /// level precision. The value will be encoded as Avro TIMESTAMP type in a
        /// 64 bit integer.
        TimestampPrecisionMicros,
        /// Timestamp values returned by Read API will be truncated to nanosecond
        /// level precision. The value will be encoded as Avro TIMESTAMP type in a
        /// 64 bit integer.
        TimestampPrecisionNanos,
        /// Read API will return full precision picosecond value. The value will be
        /// encoded as a string which conforms to ISO 8601 format.
        TimestampPrecisionPicos,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [PicosTimestampPrecision::value] or
        /// [PicosTimestampPrecision::name].
        UnknownValue(picos_timestamp_precision::UnknownValue),
    }

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

    impl PicosTimestampPrecision {
        /// 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::TimestampPrecisionMicros => std::option::Option::Some(1),
                Self::TimestampPrecisionNanos => std::option::Option::Some(2),
                Self::TimestampPrecisionPicos => 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("PICOS_TIMESTAMP_PRECISION_UNSPECIFIED")
                }
                Self::TimestampPrecisionMicros => {
                    std::option::Option::Some("TIMESTAMP_PRECISION_MICROS")
                }
                Self::TimestampPrecisionNanos => {
                    std::option::Option::Some("TIMESTAMP_PRECISION_NANOS")
                }
                Self::TimestampPrecisionPicos => {
                    std::option::Option::Some("TIMESTAMP_PRECISION_PICOS")
                }
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

    impl std::fmt::Display for PicosTimestampPrecision {
        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 PicosTimestampPrecision {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::TimestampPrecisionMicros,
                2 => Self::TimestampPrecisionNanos,
                3 => Self::TimestampPrecisionPicos,
                _ => Self::UnknownValue(picos_timestamp_precision::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for PicosTimestampPrecision {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "PICOS_TIMESTAMP_PRECISION_UNSPECIFIED" => Self::Unspecified,
                "TIMESTAMP_PRECISION_MICROS" => Self::TimestampPrecisionMicros,
                "TIMESTAMP_PRECISION_NANOS" => Self::TimestampPrecisionNanos,
                "TIMESTAMP_PRECISION_PICOS" => Self::TimestampPrecisionPicos,
                _ => Self::UnknownValue(picos_timestamp_precision::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for PicosTimestampPrecision {
        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::TimestampPrecisionMicros => serializer.serialize_i32(1),
                Self::TimestampPrecisionNanos => serializer.serialize_i32(2),
                Self::TimestampPrecisionPicos => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// ProtoSchema describes the schema of the serialized protocol buffer data rows.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ProtoSchema {
    /// Descriptor for input message.  The provided descriptor must be self
    /// contained, such that data rows sent can be fully decoded using only the
    /// single descriptor.  For data rows that are compositions of multiple
    /// independent messages, this means the descriptor may need to be transformed
    /// to only use nested types:
    /// <https://developers.google.com/protocol-buffers/docs/proto#nested>
    ///
    /// For additional information for how proto types and values map onto BigQuery
    /// see: <https://cloud.google.com/bigquery/docs/write-api#data_type_conversions>
    pub proto_descriptor: std::option::Option<wkt::DescriptorProto>,

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

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

    /// Sets the value of [proto_descriptor][crate::write::generated::gapic_storage::model::ProtoSchema::proto_descriptor].
    pub fn set_proto_descriptor<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::DescriptorProto>,
    {
        self.proto_descriptor = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [proto_descriptor][crate::write::generated::gapic_storage::model::ProtoSchema::proto_descriptor].
    pub fn set_or_clear_proto_descriptor<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::DescriptorProto>,
    {
        self.proto_descriptor = v.map(|x| x.into());
        self
    }
}

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

#[allow(missing_docs)]
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ProtoRows {
    /// A sequence of rows serialized as a Protocol Buffer.
    ///
    /// See <https://developers.google.com/protocol-buffers/docs/overview> for more
    /// information on deserializing this field.
    pub serialized_rows: std::vec::Vec<::bytes::Bytes>,

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

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

    /// Sets the value of [serialized_rows][crate::write::generated::gapic_storage::model::ProtoRows::serialized_rows].
    pub fn set_serialized_rows<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<::bytes::Bytes>,
    {
        use std::iter::Iterator;
        self.serialized_rows = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

/// Request message for `CreateReadSession`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateReadSessionRequest {
    /// Required. The request project that owns the session, in the form of
    /// `projects/{project_id}`.
    pub parent: std::string::String,

    /// Required. Session to be created.
    pub read_session:
        std::option::Option<crate::write::generated::gapic_storage::model::ReadSession>,

    /// Max initial number of streams. If unset or zero, the server will
    /// provide a value of streams so as to produce reasonable throughput. Must be
    /// non-negative. The number of streams may be lower than the requested number,
    /// depending on the amount parallelism that is reasonable for the table.
    /// There is a default system max limit of 1,000.
    ///
    /// This must be greater than or equal to preferred_min_stream_count.
    /// Typically, clients should either leave this unset to let the system to
    /// determine an upper bound OR set this a size for the maximum "units of work"
    /// it can gracefully handle.
    pub max_stream_count: i32,

    /// The minimum preferred stream count. This parameter can be used to inform
    /// the service that there is a desired lower bound on the number of streams.
    /// This is typically a target parallelism of the client (e.g. a Spark
    /// cluster with N-workers would set this to a low multiple of N to ensure
    /// good cluster utilization).
    ///
    /// The system will make a best effort to provide at least this number of
    /// streams, but in some cases might provide less.
    pub preferred_min_stream_count: i32,

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

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

    /// Sets the value of [parent][crate::write::generated::gapic_storage::model::CreateReadSessionRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [read_session][crate::write::generated::gapic_storage::model::CreateReadSessionRequest::read_session].
    pub fn set_read_session<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::ReadSession>,
    {
        self.read_session = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [read_session][crate::write::generated::gapic_storage::model::CreateReadSessionRequest::read_session].
    pub fn set_or_clear_read_session<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::ReadSession>,
    {
        self.read_session = v.map(|x| x.into());
        self
    }

    /// Sets the value of [max_stream_count][crate::write::generated::gapic_storage::model::CreateReadSessionRequest::max_stream_count].
    pub fn set_max_stream_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.max_stream_count = v.into();
        self
    }

    /// Sets the value of [preferred_min_stream_count][crate::write::generated::gapic_storage::model::CreateReadSessionRequest::preferred_min_stream_count].
    pub fn set_preferred_min_stream_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.preferred_min_stream_count = v.into();
        self
    }
}

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

/// Request message for `ReadRows`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ReadRowsRequest {

    /// Required. Stream to read rows from.
    pub read_stream: std::string::String,

    /// The offset requested must be less than the last row read from Read.
    /// Requesting a larger offset is undefined. If not specified, start reading
    /// from offset zero.
    pub offset: i64,

    /// Specifies output serialization options. Only job _default streams are
    /// supported.
    ///
    /// This feature is not yet available.
    pub output_format_serialization_options: std::option::Option<crate::write::generated::gapic_storage::model::read_rows_request::OutputFormatSerializationOptions>,

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

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

    /// Sets the value of [read_stream][crate::write::generated::gapic_storage::model::ReadRowsRequest::read_stream].
    pub fn set_read_stream<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.read_stream = v.into();
        self
    }

    /// Sets the value of [offset][crate::write::generated::gapic_storage::model::ReadRowsRequest::offset].
    pub fn set_offset<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.offset = v.into();
        self
    }

    /// Sets the value of [output_format_serialization_options][crate::write::generated::gapic_storage::model::ReadRowsRequest::output_format_serialization_options].
    ///
    /// Note that all the setters affecting `output_format_serialization_options` are mutually
    /// exclusive.
    pub fn set_output_format_serialization_options<T: std::convert::Into<std::option::Option<crate::write::generated::gapic_storage::model::read_rows_request::OutputFormatSerializationOptions>>>(mut self, v: T) -> Self
    {
        self.output_format_serialization_options = v.into();
        self
    }

    /// The value of [output_format_serialization_options][crate::write::generated::gapic_storage::model::ReadRowsRequest::output_format_serialization_options]
    /// if it holds a `ArrowSerializationOptions`, `None` if the field is not set or
    /// holds a different branch.
    pub fn arrow_serialization_options(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::write::generated::gapic_storage::model::ArrowSerializationOptions>,
    > {
        #[allow(unreachable_patterns)]
        self.output_format_serialization_options.as_ref().and_then(|v| match v {
            crate::write::generated::gapic_storage::model::read_rows_request::OutputFormatSerializationOptions::ArrowSerializationOptions(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [output_format_serialization_options][crate::write::generated::gapic_storage::model::ReadRowsRequest::output_format_serialization_options]
    /// to hold a `ArrowSerializationOptions`.
    ///
    /// Note that all the setters affecting `output_format_serialization_options` are
    /// mutually exclusive.
    pub fn set_arrow_serialization_options<
        T: std::convert::Into<
                std::boxed::Box<
                    crate::write::generated::gapic_storage::model::ArrowSerializationOptions,
                >,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.output_format_serialization_options = std::option::Option::Some(
            crate::write::generated::gapic_storage::model::read_rows_request::OutputFormatSerializationOptions::ArrowSerializationOptions(
                v.into()
            )
        );
        self
    }
}

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

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

    /// Specifies output serialization options. Only job _default streams are
    /// supported.
    ///
    /// This feature is not yet available.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum OutputFormatSerializationOptions {
        /// Optional. Options specific to the Apache Arrow output format.
        ///
        /// This feature is not yet available.
        ArrowSerializationOptions(
            std::boxed::Box<
                crate::write::generated::gapic_storage::model::ArrowSerializationOptions,
            >,
        ),
    }

    impl OutputFormatSerializationOptions {
        /// Initializes the enum to the [ArrowSerializationOptions](Self::ArrowSerializationOptions) branch.
        pub fn from_arrow_serialization_options(
            value: impl std::convert::Into<
                std::boxed::Box<
                    crate::write::generated::gapic_storage::model::ArrowSerializationOptions,
                >,
            >,
        ) -> Self {
            Self::ArrowSerializationOptions(value.into())
        }
    }
}

/// Information on if the current connection is being throttled.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ThrottleState {
    /// How much this connection is being throttled. Zero means no throttling,
    /// 100 means fully throttled.
    pub throttle_percent: i32,

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

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

    /// Sets the value of [throttle_percent][crate::write::generated::gapic_storage::model::ThrottleState::throttle_percent].
    pub fn set_throttle_percent<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.throttle_percent = v.into();
        self
    }
}

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

/// Estimated stream statistics for a given read Stream.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StreamStats {
    /// Represents the progress of the current stream.
    pub progress:
        std::option::Option<crate::write::generated::gapic_storage::model::stream_stats::Progress>,

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

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

    /// Sets the value of [progress][crate::write::generated::gapic_storage::model::StreamStats::progress].
    pub fn set_progress<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<
                crate::write::generated::gapic_storage::model::stream_stats::Progress,
            >,
    {
        self.progress = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [progress][crate::write::generated::gapic_storage::model::StreamStats::progress].
    pub fn set_or_clear_progress<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<
                crate::write::generated::gapic_storage::model::stream_stats::Progress,
            >,
    {
        self.progress = v.map(|x| x.into());
        self
    }
}

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

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

    #[allow(missing_docs)]
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Progress {
        /// The fraction of rows assigned to the stream that have been processed by
        /// the server so far, not including the rows in the current response
        /// message.
        ///
        /// This value, along with `at_response_end`, can be used to interpolate
        /// the progress made as the rows in the message are being processed using
        /// the following formula: `at_response_start + (at_response_end -
        /// at_response_start) * rows_processed_from_response / rows_in_response`.
        ///
        /// Note that if a filter is provided, the `at_response_end` value of the
        /// previous response may not necessarily be equal to the
        /// `at_response_start` value of the current response.
        pub at_response_start: f64,

        /// Similar to `at_response_start`, except that this value includes the
        /// rows in the current response.
        pub at_response_end: f64,

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

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

        /// Sets the value of [at_response_start][crate::write::generated::gapic_storage::model::stream_stats::Progress::at_response_start].
        pub fn set_at_response_start<T: std::convert::Into<f64>>(mut self, v: T) -> Self {
            self.at_response_start = v.into();
            self
        }

        /// Sets the value of [at_response_end][crate::write::generated::gapic_storage::model::stream_stats::Progress::at_response_end].
        pub fn set_at_response_end<T: std::convert::Into<f64>>(mut self, v: T) -> Self {
            self.at_response_end = v.into();
            self
        }
    }

    impl wkt::message::Message for Progress {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.bigquery.storage.v1.StreamStats.Progress"
        }
    }
}

/// Response from calling `ReadRows` may include row data, progress and
/// throttling information.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ReadRowsResponse {
    /// Number of serialized rows in the rows block.
    pub row_count: i64,

    /// Statistics for the stream.
    pub stats: std::option::Option<crate::write::generated::gapic_storage::model::StreamStats>,

    /// Throttling state. If unset, the latest response still describes
    /// the current throttling status.
    pub throttle_state:
        std::option::Option<crate::write::generated::gapic_storage::model::ThrottleState>,

    /// Optional. If the row data in this ReadRowsResponse is compressed, then
    /// uncompressed byte size is the original size of the uncompressed row data.
    /// If it is set to a value greater than 0, then decompress into a buffer of
    /// size uncompressed_byte_size using the compression codec that was requested
    /// during session creation time and which is specified in
    /// TableReadOptions.response_compression_codec in ReadSession.
    /// This value is not set if no response_compression_codec was not requested
    /// and it is -1 if the requested compression would not have reduced the size
    /// of this ReadRowsResponse's row data. This attempts to match Apache Arrow's
    /// behavior described here <https://github.com/apache/arrow/issues/15102> where
    /// the uncompressed length may be set to -1 to indicate that the data that
    /// follows is not compressed, which can be useful for cases where compression
    /// does not yield appreciable savings. When uncompressed_byte_size is not
    /// greater than 0, the client should skip decompression.
    pub uncompressed_byte_size: std::option::Option<i64>,

    /// Output only. The total estimated number of rows in the query results.
    /// Only populated when reading data from a BigQuery job.
    ///
    /// This feature is not yet available.
    pub total_estimated_row_count: std::option::Option<i64>,

    /// Row data is returned in format specified during session creation.
    pub rows: std::option::Option<
        crate::write::generated::gapic_storage::model::read_rows_response::Rows,
    >,

    /// The schema for the read. If read_options.selected_fields is set, the
    /// schema may be different from the table schema as it will only contain
    /// the selected fields. This schema is equivalent to the one returned by
    /// CreateSession. This field is only populated in the first ReadRowsResponse
    /// RPC.
    pub schema: std::option::Option<
        crate::write::generated::gapic_storage::model::read_rows_response::Schema,
    >,

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

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

    /// Sets the value of [row_count][crate::write::generated::gapic_storage::model::ReadRowsResponse::row_count].
    pub fn set_row_count<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.row_count = v.into();
        self
    }

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

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

    /// Sets the value of [throttle_state][crate::write::generated::gapic_storage::model::ReadRowsResponse::throttle_state].
    pub fn set_throttle_state<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::ThrottleState>,
    {
        self.throttle_state = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [throttle_state][crate::write::generated::gapic_storage::model::ReadRowsResponse::throttle_state].
    pub fn set_or_clear_throttle_state<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::ThrottleState>,
    {
        self.throttle_state = v.map(|x| x.into());
        self
    }

    /// Sets the value of [uncompressed_byte_size][crate::write::generated::gapic_storage::model::ReadRowsResponse::uncompressed_byte_size].
    pub fn set_uncompressed_byte_size<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i64>,
    {
        self.uncompressed_byte_size = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [uncompressed_byte_size][crate::write::generated::gapic_storage::model::ReadRowsResponse::uncompressed_byte_size].
    pub fn set_or_clear_uncompressed_byte_size<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i64>,
    {
        self.uncompressed_byte_size = v.map(|x| x.into());
        self
    }

    /// Sets the value of [total_estimated_row_count][crate::write::generated::gapic_storage::model::ReadRowsResponse::total_estimated_row_count].
    pub fn set_total_estimated_row_count<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i64>,
    {
        self.total_estimated_row_count = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [total_estimated_row_count][crate::write::generated::gapic_storage::model::ReadRowsResponse::total_estimated_row_count].
    pub fn set_or_clear_total_estimated_row_count<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i64>,
    {
        self.total_estimated_row_count = v.map(|x| x.into());
        self
    }

    /// Sets the value of [rows][crate::write::generated::gapic_storage::model::ReadRowsResponse::rows].
    ///
    /// Note that all the setters affecting `rows` are mutually
    /// exclusive.
    pub fn set_rows<
        T: std::convert::Into<
                std::option::Option<
                    crate::write::generated::gapic_storage::model::read_rows_response::Rows,
                >,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.rows = v.into();
        self
    }

    /// The value of [rows][crate::write::generated::gapic_storage::model::ReadRowsResponse::rows]
    /// if it holds a `AvroRows`, `None` if the field is not set or
    /// holds a different branch.
    pub fn avro_rows(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::write::generated::gapic_storage::model::AvroRows>,
    > {
        #[allow(unreachable_patterns)]
        self.rows.as_ref().and_then(|v| match v {
            crate::write::generated::gapic_storage::model::read_rows_response::Rows::AvroRows(
                v,
            ) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [rows][crate::write::generated::gapic_storage::model::ReadRowsResponse::rows]
    /// to hold a `AvroRows`.
    ///
    /// Note that all the setters affecting `rows` are
    /// mutually exclusive.
    pub fn set_avro_rows<
        T: std::convert::Into<
                std::boxed::Box<crate::write::generated::gapic_storage::model::AvroRows>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.rows = std::option::Option::Some(
            crate::write::generated::gapic_storage::model::read_rows_response::Rows::AvroRows(
                v.into(),
            ),
        );
        self
    }

    /// The value of [rows][crate::write::generated::gapic_storage::model::ReadRowsResponse::rows]
    /// if it holds a `ArrowRecordBatch`, `None` if the field is not set or
    /// holds a different branch.
    pub fn arrow_record_batch(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::write::generated::gapic_storage::model::ArrowRecordBatch>,
    > {
        #[allow(unreachable_patterns)]
        self.rows.as_ref().and_then(|v| match v {
            crate::write::generated::gapic_storage::model::read_rows_response::Rows::ArrowRecordBatch(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [rows][crate::write::generated::gapic_storage::model::ReadRowsResponse::rows]
    /// to hold a `ArrowRecordBatch`.
    ///
    /// Note that all the setters affecting `rows` are
    /// mutually exclusive.
    pub fn set_arrow_record_batch<
        T: std::convert::Into<
                std::boxed::Box<crate::write::generated::gapic_storage::model::ArrowRecordBatch>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.rows = std::option::Option::Some(
            crate::write::generated::gapic_storage::model::read_rows_response::Rows::ArrowRecordBatch(
                v.into()
            )
        );
        self
    }

    /// Sets the value of [schema][crate::write::generated::gapic_storage::model::ReadRowsResponse::schema].
    ///
    /// Note that all the setters affecting `schema` are mutually
    /// exclusive.
    pub fn set_schema<
        T: std::convert::Into<
                std::option::Option<
                    crate::write::generated::gapic_storage::model::read_rows_response::Schema,
                >,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.schema = v.into();
        self
    }

    /// The value of [schema][crate::write::generated::gapic_storage::model::ReadRowsResponse::schema]
    /// if it holds a `AvroSchema`, `None` if the field is not set or
    /// holds a different branch.
    pub fn avro_schema(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::write::generated::gapic_storage::model::AvroSchema>,
    > {
        #[allow(unreachable_patterns)]
        self.schema.as_ref().and_then(|v| match v {
            crate::write::generated::gapic_storage::model::read_rows_response::Schema::AvroSchema(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [schema][crate::write::generated::gapic_storage::model::ReadRowsResponse::schema]
    /// to hold a `AvroSchema`.
    ///
    /// Note that all the setters affecting `schema` are
    /// mutually exclusive.
    pub fn set_avro_schema<
        T: std::convert::Into<
                std::boxed::Box<crate::write::generated::gapic_storage::model::AvroSchema>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.schema = std::option::Option::Some(
            crate::write::generated::gapic_storage::model::read_rows_response::Schema::AvroSchema(
                v.into(),
            ),
        );
        self
    }

    /// The value of [schema][crate::write::generated::gapic_storage::model::ReadRowsResponse::schema]
    /// if it holds a `ArrowSchema`, `None` if the field is not set or
    /// holds a different branch.
    pub fn arrow_schema(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::write::generated::gapic_storage::model::ArrowSchema>,
    > {
        #[allow(unreachable_patterns)]
        self.schema.as_ref().and_then(|v| match v {
            crate::write::generated::gapic_storage::model::read_rows_response::Schema::ArrowSchema(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [schema][crate::write::generated::gapic_storage::model::ReadRowsResponse::schema]
    /// to hold a `ArrowSchema`.
    ///
    /// Note that all the setters affecting `schema` are
    /// mutually exclusive.
    pub fn set_arrow_schema<
        T: std::convert::Into<
                std::boxed::Box<crate::write::generated::gapic_storage::model::ArrowSchema>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.schema = std::option::Option::Some(
            crate::write::generated::gapic_storage::model::read_rows_response::Schema::ArrowSchema(
                v.into(),
            ),
        );
        self
    }
}

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

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

    /// Row data is returned in format specified during session creation.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Rows {
        /// Serialized row data in AVRO format.
        AvroRows(std::boxed::Box<crate::write::generated::gapic_storage::model::AvroRows>),
        /// Serialized row data in Arrow RecordBatch format.
        ArrowRecordBatch(
            std::boxed::Box<crate::write::generated::gapic_storage::model::ArrowRecordBatch>,
        ),
    }

    impl Rows {
        /// Initializes the enum to the [AvroRows](Self::AvroRows) branch.
        pub fn from_avro_rows(
            value: impl std::convert::Into<
                std::boxed::Box<crate::write::generated::gapic_storage::model::AvroRows>,
            >,
        ) -> Self {
            Self::AvroRows(value.into())
        }
        /// Initializes the enum to the [ArrowRecordBatch](Self::ArrowRecordBatch) branch.
        pub fn from_arrow_record_batch(
            value: impl std::convert::Into<
                std::boxed::Box<crate::write::generated::gapic_storage::model::ArrowRecordBatch>,
            >,
        ) -> Self {
            Self::ArrowRecordBatch(value.into())
        }
    }

    /// The schema for the read. If read_options.selected_fields is set, the
    /// schema may be different from the table schema as it will only contain
    /// the selected fields. This schema is equivalent to the one returned by
    /// CreateSession. This field is only populated in the first ReadRowsResponse
    /// RPC.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Schema {
        /// Output only. Avro schema.
        AvroSchema(std::boxed::Box<crate::write::generated::gapic_storage::model::AvroSchema>),
        /// Output only. Arrow schema.
        ArrowSchema(std::boxed::Box<crate::write::generated::gapic_storage::model::ArrowSchema>),
    }

    impl Schema {
        /// Initializes the enum to the [AvroSchema](Self::AvroSchema) branch.
        pub fn from_avro_schema(
            value: impl std::convert::Into<
                std::boxed::Box<crate::write::generated::gapic_storage::model::AvroSchema>,
            >,
        ) -> Self {
            Self::AvroSchema(value.into())
        }
        /// Initializes the enum to the [ArrowSchema](Self::ArrowSchema) branch.
        pub fn from_arrow_schema(
            value: impl std::convert::Into<
                std::boxed::Box<crate::write::generated::gapic_storage::model::ArrowSchema>,
            >,
        ) -> Self {
            Self::ArrowSchema(value.into())
        }
    }
}

/// Request message for `SplitReadStream`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SplitReadStreamRequest {
    /// Required. Name of the stream to split.
    pub name: std::string::String,

    /// A value in the range (0.0, 1.0) that specifies the fractional point at
    /// which the original stream should be split. The actual split point is
    /// evaluated on pre-filtered rows, so if a filter is provided, then there is
    /// no guarantee that the division of the rows between the new child streams
    /// will be proportional to this fractional value. Additionally, because the
    /// server-side unit for assigning data is collections of rows, this fraction
    /// will always map to a data storage boundary on the server side.
    pub fraction: f64,

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

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

    /// Sets the value of [name][crate::write::generated::gapic_storage::model::SplitReadStreamRequest::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 [fraction][crate::write::generated::gapic_storage::model::SplitReadStreamRequest::fraction].
    pub fn set_fraction<T: std::convert::Into<f64>>(mut self, v: T) -> Self {
        self.fraction = v.into();
        self
    }
}

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

/// Response message for `SplitReadStream`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SplitReadStreamResponse {
    /// Primary stream, which contains the beginning portion of
    /// |original_stream|. An empty value indicates that the original stream can no
    /// longer be split.
    pub primary_stream:
        std::option::Option<crate::write::generated::gapic_storage::model::ReadStream>,

    /// Remainder stream, which contains the tail of |original_stream|. An empty
    /// value indicates that the original stream can no longer be split.
    pub remainder_stream:
        std::option::Option<crate::write::generated::gapic_storage::model::ReadStream>,

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

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

    /// Sets the value of [primary_stream][crate::write::generated::gapic_storage::model::SplitReadStreamResponse::primary_stream].
    pub fn set_primary_stream<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::ReadStream>,
    {
        self.primary_stream = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [primary_stream][crate::write::generated::gapic_storage::model::SplitReadStreamResponse::primary_stream].
    pub fn set_or_clear_primary_stream<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::ReadStream>,
    {
        self.primary_stream = v.map(|x| x.into());
        self
    }

    /// Sets the value of [remainder_stream][crate::write::generated::gapic_storage::model::SplitReadStreamResponse::remainder_stream].
    pub fn set_remainder_stream<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::ReadStream>,
    {
        self.remainder_stream = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [remainder_stream][crate::write::generated::gapic_storage::model::SplitReadStreamResponse::remainder_stream].
    pub fn set_or_clear_remainder_stream<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::ReadStream>,
    {
        self.remainder_stream = v.map(|x| x.into());
        self
    }
}

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

/// Request message for `CreateWriteStream`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateWriteStreamRequest {
    /// Required. Reference to the table to which the stream belongs, in the format
    /// of `projects/{project}/datasets/{dataset}/tables/{table}`.
    pub parent: std::string::String,

    /// Required. Stream to be created.
    pub write_stream:
        std::option::Option<crate::write::generated::gapic_storage::model::WriteStream>,

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

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

    /// Sets the value of [parent][crate::write::generated::gapic_storage::model::CreateWriteStreamRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [write_stream][crate::write::generated::gapic_storage::model::CreateWriteStreamRequest::write_stream].
    pub fn set_write_stream<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::WriteStream>,
    {
        self.write_stream = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [write_stream][crate::write::generated::gapic_storage::model::CreateWriteStreamRequest::write_stream].
    pub fn set_or_clear_write_stream<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::WriteStream>,
    {
        self.write_stream = v.map(|x| x.into());
        self
    }
}

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

/// Request message for `AppendRows`.
///
/// Because AppendRows is a bidirectional streaming RPC, certain parts of the
/// AppendRowsRequest need only be specified for the first request before
/// switching table destinations. You can also switch table destinations within
/// the same connection for the default stream.
///
/// The size of a single AppendRowsRequest must be less than 20 MB in size.
/// Requests larger than this return an error, typically `INVALID_ARGUMENT`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AppendRowsRequest {

    /// Required. The write_stream identifies the append operation. It must be
    /// provided in the following scenarios:
    ///
    /// * In the first request to an AppendRows connection.
    ///
    /// * In all subsequent requests to an AppendRows connection, if you use the
    ///   same connection to write to multiple tables or change the input schema for
    ///   default streams.
    ///
    ///
    /// For explicitly created write streams, the format is:
    ///
    /// * `projects/{project}/datasets/{dataset}/tables/{table}/streams/{id}`
    ///
    /// For the special default stream, the format is:
    ///
    /// * `projects/{project}/datasets/{dataset}/tables/{table}/streams/_default`.
    ///
    /// An example of a possible sequence of requests with write_stream fields
    /// within a single connection:
    ///
    /// * r1: {write_stream: stream_name_1}
    ///
    /// * r2: {write_stream: /*omit*/}
    ///
    /// * r3: {write_stream: /*omit*/}
    ///
    /// * r4: {write_stream: stream_name_2}
    ///
    /// * r5: {write_stream: stream_name_2}
    ///
    ///
    /// The destination changed in request_4, so the write_stream field must be
    /// populated in all subsequent requests in this stream.
    pub write_stream: std::string::String,

    /// If present, the write is only performed if the next append offset is same
    /// as the provided value. If not present, the write is performed at the
    /// current end of stream. Specifying a value for this field is not allowed
    /// when calling AppendRows for the '_default' stream.
    pub offset: std::option::Option<wkt::Int64Value>,

    /// Id set by client to annotate its identity. Only initial request setting is
    /// respected.
    pub trace_id: std::string::String,

    /// A map to indicate how to interpret missing value for some fields. Missing
    /// values are fields present in user schema but missing in rows. The key is
    /// the field name. The value is the interpretation of missing values for the
    /// field.
    ///
    /// For example, a map {'foo': NULL_VALUE, 'bar': DEFAULT_VALUE} means all
    /// missing values in field foo are interpreted as NULL, all missing values in
    /// field bar are interpreted as the default value of field bar in table
    /// schema.
    ///
    /// If a field is not in this map and has missing values, the missing values
    /// in this field are interpreted as NULL.
    ///
    /// This field only applies to the current request, it won't affect other
    /// requests on the connection.
    ///
    /// Currently, field name can only be top-level column name, can't be a struct
    /// field path like 'foo.bar'.
    pub missing_value_interpretations: std::collections::HashMap<std::string::String,crate::write::generated::gapic_storage::model::append_rows_request::MissingValueInterpretation>,

    /// Optional. Default missing value interpretation for all columns in the
    /// table. When a value is specified on an `AppendRowsRequest`, it is applied
    /// to all requests from that point forward, until a subsequent
    /// `AppendRowsRequest` sets it to a different value.
    /// `missing_value_interpretation` can override
    /// `default_missing_value_interpretation`. For example, if you want to write
    /// `NULL` instead of using default values for some columns, you can set
    /// `default_missing_value_interpretation` to `DEFAULT_VALUE` and at the same
    /// time, set `missing_value_interpretations` to `NULL_VALUE` on those columns.
    pub default_missing_value_interpretation: crate::write::generated::gapic_storage::model::append_rows_request::MissingValueInterpretation,

    /// Optional. Stats and telemetry data gathered on the client side.
    pub client_stats: std::option::Option<crate::write::generated::gapic_storage::model::ClientStats>,

    /// Input rows. The `writer_schema` field must be specified at the initial
    /// request and currently, it will be ignored if specified in following
    /// requests. Following requests must have data in the same format as the
    /// initial request.
    pub rows: std::option::Option<crate::write::generated::gapic_storage::model::append_rows_request::Rows>,

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

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

    /// Sets the value of [write_stream][crate::write::generated::gapic_storage::model::AppendRowsRequest::write_stream].
    pub fn set_write_stream<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.write_stream = v.into();
        self
    }

    /// Sets the value of [offset][crate::write::generated::gapic_storage::model::AppendRowsRequest::offset].
    pub fn set_offset<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Int64Value>,
    {
        self.offset = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [offset][crate::write::generated::gapic_storage::model::AppendRowsRequest::offset].
    pub fn set_or_clear_offset<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Int64Value>,
    {
        self.offset = v.map(|x| x.into());
        self
    }

    /// Sets the value of [trace_id][crate::write::generated::gapic_storage::model::AppendRowsRequest::trace_id].
    pub fn set_trace_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.trace_id = v.into();
        self
    }

    /// Sets the value of [missing_value_interpretations][crate::write::generated::gapic_storage::model::AppendRowsRequest::missing_value_interpretations].
    pub fn set_missing_value_interpretations<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::write::generated::gapic_storage::model::append_rows_request::MissingValueInterpretation>,
    {
        use std::iter::Iterator;
        self.missing_value_interpretations =
            v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [default_missing_value_interpretation][crate::write::generated::gapic_storage::model::AppendRowsRequest::default_missing_value_interpretation].
    pub fn set_default_missing_value_interpretation<T: std::convert::Into<crate::write::generated::gapic_storage::model::append_rows_request::MissingValueInterpretation>>(mut self, v: T) -> Self{
        self.default_missing_value_interpretation = v.into();
        self
    }

    /// Sets the value of [client_stats][crate::write::generated::gapic_storage::model::AppendRowsRequest::client_stats].
    pub fn set_client_stats<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::ClientStats>,
    {
        self.client_stats = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [client_stats][crate::write::generated::gapic_storage::model::AppendRowsRequest::client_stats].
    pub fn set_or_clear_client_stats<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::ClientStats>,
    {
        self.client_stats = v.map(|x| x.into());
        self
    }

    /// Sets the value of [rows][crate::write::generated::gapic_storage::model::AppendRowsRequest::rows].
    ///
    /// Note that all the setters affecting `rows` are mutually
    /// exclusive.
    pub fn set_rows<
        T: std::convert::Into<
                std::option::Option<
                    crate::write::generated::gapic_storage::model::append_rows_request::Rows,
                >,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.rows = v.into();
        self
    }

    /// The value of [rows][crate::write::generated::gapic_storage::model::AppendRowsRequest::rows]
    /// if it holds a `ProtoRows`, `None` if the field is not set or
    /// holds a different branch.
    pub fn proto_rows(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<
            crate::write::generated::gapic_storage::model::append_rows_request::ProtoData,
        >,
    > {
        #[allow(unreachable_patterns)]
        self.rows.as_ref().and_then(|v| match v {
            crate::write::generated::gapic_storage::model::append_rows_request::Rows::ProtoRows(
                v,
            ) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [rows][crate::write::generated::gapic_storage::model::AppendRowsRequest::rows]
    /// to hold a `ProtoRows`.
    ///
    /// Note that all the setters affecting `rows` are
    /// mutually exclusive.
    pub fn set_proto_rows<
        T: std::convert::Into<
                std::boxed::Box<
                    crate::write::generated::gapic_storage::model::append_rows_request::ProtoData,
                >,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.rows = std::option::Option::Some(
            crate::write::generated::gapic_storage::model::append_rows_request::Rows::ProtoRows(
                v.into(),
            ),
        );
        self
    }

    /// The value of [rows][crate::write::generated::gapic_storage::model::AppendRowsRequest::rows]
    /// if it holds a `ArrowRows`, `None` if the field is not set or
    /// holds a different branch.
    pub fn arrow_rows(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<
            crate::write::generated::gapic_storage::model::append_rows_request::ArrowData,
        >,
    > {
        #[allow(unreachable_patterns)]
        self.rows.as_ref().and_then(|v| match v {
            crate::write::generated::gapic_storage::model::append_rows_request::Rows::ArrowRows(
                v,
            ) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [rows][crate::write::generated::gapic_storage::model::AppendRowsRequest::rows]
    /// to hold a `ArrowRows`.
    ///
    /// Note that all the setters affecting `rows` are
    /// mutually exclusive.
    pub fn set_arrow_rows<
        T: std::convert::Into<
                std::boxed::Box<
                    crate::write::generated::gapic_storage::model::append_rows_request::ArrowData,
                >,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.rows = std::option::Option::Some(
            crate::write::generated::gapic_storage::model::append_rows_request::Rows::ArrowRows(
                v.into(),
            ),
        );
        self
    }
}

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

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

    /// Arrow schema and data.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ArrowData {
        /// Optional. Arrow Schema used to serialize the data.
        pub writer_schema:
            std::option::Option<crate::write::generated::gapic_storage::model::ArrowSchema>,

        /// Required. Serialized row data in Arrow format.
        pub rows:
            std::option::Option<crate::write::generated::gapic_storage::model::ArrowRecordBatch>,

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

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

        /// Sets the value of [writer_schema][crate::write::generated::gapic_storage::model::append_rows_request::ArrowData::writer_schema].
        pub fn set_writer_schema<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::write::generated::gapic_storage::model::ArrowSchema>,
        {
            self.writer_schema = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [writer_schema][crate::write::generated::gapic_storage::model::append_rows_request::ArrowData::writer_schema].
        pub fn set_or_clear_writer_schema<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::write::generated::gapic_storage::model::ArrowSchema>,
        {
            self.writer_schema = v.map(|x| x.into());
            self
        }

        /// Sets the value of [rows][crate::write::generated::gapic_storage::model::append_rows_request::ArrowData::rows].
        pub fn set_rows<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::write::generated::gapic_storage::model::ArrowRecordBatch>,
        {
            self.rows = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [rows][crate::write::generated::gapic_storage::model::append_rows_request::ArrowData::rows].
        pub fn set_or_clear_rows<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::write::generated::gapic_storage::model::ArrowRecordBatch>,
        {
            self.rows = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for ArrowData {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.bigquery.storage.v1.AppendRowsRequest.ArrowData"
        }
    }

    /// ProtoData contains the data rows and schema when constructing append
    /// requests.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ProtoData {
        /// Optional. The protocol buffer schema used to serialize the data. Provide
        /// this value whenever:
        ///
        /// * You send the first request of an RPC connection.
        ///
        /// * You change the input schema.
        ///
        /// * You specify a new destination table.
        ///
        pub writer_schema:
            std::option::Option<crate::write::generated::gapic_storage::model::ProtoSchema>,

        /// Required. Serialized row data in protobuf message format.
        /// Currently, the backend expects the serialized rows to adhere to
        /// proto2 semantics when appending rows, particularly with respect to
        /// how default values are encoded.
        pub rows: std::option::Option<crate::write::generated::gapic_storage::model::ProtoRows>,

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

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

        /// Sets the value of [writer_schema][crate::write::generated::gapic_storage::model::append_rows_request::ProtoData::writer_schema].
        pub fn set_writer_schema<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::write::generated::gapic_storage::model::ProtoSchema>,
        {
            self.writer_schema = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [writer_schema][crate::write::generated::gapic_storage::model::append_rows_request::ProtoData::writer_schema].
        pub fn set_or_clear_writer_schema<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::write::generated::gapic_storage::model::ProtoSchema>,
        {
            self.writer_schema = v.map(|x| x.into());
            self
        }

        /// Sets the value of [rows][crate::write::generated::gapic_storage::model::append_rows_request::ProtoData::rows].
        pub fn set_rows<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::write::generated::gapic_storage::model::ProtoRows>,
        {
            self.rows = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [rows][crate::write::generated::gapic_storage::model::append_rows_request::ProtoData::rows].
        pub fn set_or_clear_rows<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::write::generated::gapic_storage::model::ProtoRows>,
        {
            self.rows = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for ProtoData {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.bigquery.storage.v1.AppendRowsRequest.ProtoData"
        }
    }

    /// An enum to indicate how to interpret missing values of fields that are
    /// present in user schema but missing in rows. A missing value can represent a
    /// NULL or a column default value defined in BigQuery table schema.
    ///
    /// # 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 MissingValueInterpretation {
        /// Invalid missing value interpretation. Requests with this value will be
        /// rejected.
        Unspecified,
        /// Missing value is interpreted as NULL.
        NullValue,
        /// Missing value is interpreted as column default value if declared in the
        /// table schema, NULL otherwise.
        DefaultValue,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [MissingValueInterpretation::value] or
        /// [MissingValueInterpretation::name].
        UnknownValue(missing_value_interpretation::UnknownValue),
    }

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

    impl MissingValueInterpretation {
        /// 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::NullValue => std::option::Option::Some(1),
                Self::DefaultValue => 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("MISSING_VALUE_INTERPRETATION_UNSPECIFIED")
                }
                Self::NullValue => std::option::Option::Some("NULL_VALUE"),
                Self::DefaultValue => std::option::Option::Some("DEFAULT_VALUE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

    impl std::fmt::Display for MissingValueInterpretation {
        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 MissingValueInterpretation {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::NullValue,
                2 => Self::DefaultValue,
                _ => Self::UnknownValue(missing_value_interpretation::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for MissingValueInterpretation {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "MISSING_VALUE_INTERPRETATION_UNSPECIFIED" => Self::Unspecified,
                "NULL_VALUE" => Self::NullValue,
                "DEFAULT_VALUE" => Self::DefaultValue,
                _ => Self::UnknownValue(missing_value_interpretation::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for MissingValueInterpretation {
        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::NullValue => serializer.serialize_i32(1),
                Self::DefaultValue => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

    /// Input rows. The `writer_schema` field must be specified at the initial
    /// request and currently, it will be ignored if specified in following
    /// requests. Following requests must have data in the same format as the
    /// initial request.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Rows {
        /// Rows in proto format.
        ProtoRows(
            std::boxed::Box<
                crate::write::generated::gapic_storage::model::append_rows_request::ProtoData,
            >,
        ),
        /// Rows in arrow format.
        ArrowRows(
            std::boxed::Box<
                crate::write::generated::gapic_storage::model::append_rows_request::ArrowData,
            >,
        ),
    }

    impl Rows {
        /// Initializes the enum to the [ProtoRows](Self::ProtoRows) branch.
        pub fn from_proto_rows(
            value: impl std::convert::Into<
                std::boxed::Box<
                    crate::write::generated::gapic_storage::model::append_rows_request::ProtoData,
                >,
            >,
        ) -> Self {
            Self::ProtoRows(value.into())
        }
        /// Initializes the enum to the [ArrowRows](Self::ArrowRows) branch.
        pub fn from_arrow_rows(
            value: impl std::convert::Into<
                std::boxed::Box<
                    crate::write::generated::gapic_storage::model::append_rows_request::ArrowData,
                >,
            >,
        ) -> Self {
            Self::ArrowRows(value.into())
        }
    }
}

/// Response message for `AppendRows`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AppendRowsResponse {
    /// If backend detects a schema update, pass it to user so that user can
    /// use it to input new type of message. It will be empty when no schema
    /// updates have occurred.
    pub updated_schema:
        std::option::Option<crate::write::generated::gapic_storage::model::TableSchema>,

    /// If a request failed due to corrupted rows, no rows in the batch will be
    /// appended. The API will return row level error info, so that the caller can
    /// remove the bad rows and retry the request.
    pub row_errors: std::vec::Vec<crate::write::generated::gapic_storage::model::RowError>,

    /// The target of the append operation. Matches the write_stream in the
    /// corresponding request.
    pub write_stream: std::string::String,

    #[allow(missing_docs)]
    pub response: std::option::Option<
        crate::write::generated::gapic_storage::model::append_rows_response::Response,
    >,

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

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

    /// Sets the value of [updated_schema][crate::write::generated::gapic_storage::model::AppendRowsResponse::updated_schema].
    pub fn set_updated_schema<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::TableSchema>,
    {
        self.updated_schema = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [updated_schema][crate::write::generated::gapic_storage::model::AppendRowsResponse::updated_schema].
    pub fn set_or_clear_updated_schema<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::TableSchema>,
    {
        self.updated_schema = v.map(|x| x.into());
        self
    }

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

    /// Sets the value of [write_stream][crate::write::generated::gapic_storage::model::AppendRowsResponse::write_stream].
    pub fn set_write_stream<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.write_stream = v.into();
        self
    }

    /// Sets the value of [response][crate::write::generated::gapic_storage::model::AppendRowsResponse::response].
    ///
    /// Note that all the setters affecting `response` are mutually
    /// exclusive.
    pub fn set_response<
        T: std::convert::Into<
                std::option::Option<
                    crate::write::generated::gapic_storage::model::append_rows_response::Response,
                >,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.response = v.into();
        self
    }

    /// The value of [response][crate::write::generated::gapic_storage::model::AppendRowsResponse::response]
    /// if it holds a `AppendResult`, `None` if the field is not set or
    /// holds a different branch.
    pub fn append_result(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<
            crate::write::generated::gapic_storage::model::append_rows_response::AppendResult,
        >,
    > {
        #[allow(unreachable_patterns)]
        self.response.as_ref().and_then(|v| match v {
            crate::write::generated::gapic_storage::model::append_rows_response::Response::AppendResult(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [response][crate::write::generated::gapic_storage::model::AppendRowsResponse::response]
    /// to hold a `AppendResult`.
    ///
    /// Note that all the setters affecting `response` are
    /// mutually exclusive.
    pub fn set_append_result<T: std::convert::Into<std::boxed::Box<crate::write::generated::gapic_storage::model::append_rows_response::AppendResult>>>(mut self, v: T) -> Self{
        self.response = std::option::Option::Some(
            crate::write::generated::gapic_storage::model::append_rows_response::Response::AppendResult(
                v.into()
            )
        );
        self
    }

    /// The value of [response][crate::write::generated::gapic_storage::model::AppendRowsResponse::response]
    /// if it holds a `Error`, `None` if the field is not set or
    /// holds a different branch.
    pub fn error(&self) -> std::option::Option<&std::boxed::Box<google_cloud_rpc::model::Status>> {
        #[allow(unreachable_patterns)]
        self.response.as_ref().and_then(|v| match v {
            crate::write::generated::gapic_storage::model::append_rows_response::Response::Error(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [response][crate::write::generated::gapic_storage::model::AppendRowsResponse::response]
    /// to hold a `Error`.
    ///
    /// Note that all the setters affecting `response` are
    /// mutually exclusive.
    pub fn set_error<T: std::convert::Into<std::boxed::Box<google_cloud_rpc::model::Status>>>(
        mut self,
        v: T,
    ) -> Self {
        self.response = std::option::Option::Some(
            crate::write::generated::gapic_storage::model::append_rows_response::Response::Error(
                v.into(),
            ),
        );
        self
    }
}

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

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

    /// AppendResult is returned for successful append requests.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct AppendResult {
        /// The row offset at which the last append occurred. The offset will not be
        /// set if appending using default streams.
        pub offset: std::option::Option<wkt::Int64Value>,

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

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

        /// Sets the value of [offset][crate::write::generated::gapic_storage::model::append_rows_response::AppendResult::offset].
        pub fn set_offset<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Int64Value>,
        {
            self.offset = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [offset][crate::write::generated::gapic_storage::model::append_rows_response::AppendResult::offset].
        pub fn set_or_clear_offset<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Int64Value>,
        {
            self.offset = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for AppendResult {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.bigquery.storage.v1.AppendRowsResponse.AppendResult"
        }
    }

    #[allow(missing_docs)]
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Response {
        /// Result if the append is successful.
        AppendResult(
            std::boxed::Box<
                crate::write::generated::gapic_storage::model::append_rows_response::AppendResult,
            >,
        ),
        /// Error returned when problems were encountered.  If present,
        /// it indicates rows were not accepted into the system.
        /// Users can retry or continue with other append requests within the
        /// same connection.
        ///
        /// Additional information about error signalling:
        ///
        /// ALREADY_EXISTS: Happens when an append specified an offset, and the
        /// backend already has received data at this offset.  Typically encountered
        /// in retry scenarios, and can be ignored.
        ///
        /// OUT_OF_RANGE: Returned when the specified offset in the stream is beyond
        /// the current end of the stream.
        ///
        /// INVALID_ARGUMENT: Indicates a malformed request or data.
        ///
        /// ABORTED: Request processing is aborted because of prior failures.  The
        /// request can be retried if previous failure is addressed.
        ///
        /// INTERNAL: Indicates server side error(s) that can be retried.
        Error(std::boxed::Box<google_cloud_rpc::model::Status>),
    }

    impl Response {
        /// Initializes the enum to the [AppendResult](Self::AppendResult) branch.
        pub fn from_append_result(
            value: impl std::convert::Into<std::boxed::Box<crate::write::generated::gapic_storage::model::append_rows_response::AppendResult>>,
        ) -> Self {
            Self::AppendResult(value.into())
        }
        /// Initializes the enum to the [Error](Self::Error) branch.
        pub fn from_error(
            value: impl std::convert::Into<std::boxed::Box<google_cloud_rpc::model::Status>>,
        ) -> Self {
            Self::Error(value.into())
        }
    }
}

/// Request message for `GetWriteStreamRequest`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetWriteStreamRequest {
    /// Required. Name of the stream to get, in the form of
    /// `projects/{project}/datasets/{dataset}/tables/{table}/streams/{stream}`.
    pub name: std::string::String,

    /// Indicates whether to get full or partial view of the WriteStream. If
    /// not set, view returned will be basic.
    pub view: crate::write::generated::gapic_storage::model::WriteStreamView,

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

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

    /// Sets the value of [name][crate::write::generated::gapic_storage::model::GetWriteStreamRequest::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 [view][crate::write::generated::gapic_storage::model::GetWriteStreamRequest::view].
    pub fn set_view<
        T: std::convert::Into<crate::write::generated::gapic_storage::model::WriteStreamView>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.view = v.into();
        self
    }
}

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

/// Request message for `BatchCommitWriteStreams`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchCommitWriteStreamsRequest {
    /// Required. Parent table that all the streams should belong to, in the form
    /// of `projects/{project}/datasets/{dataset}/tables/{table}`.
    pub parent: std::string::String,

    /// Required. The group of streams that will be committed atomically.
    pub write_streams: std::vec::Vec<std::string::String>,

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

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

    /// Sets the value of [parent][crate::write::generated::gapic_storage::model::BatchCommitWriteStreamsRequest::parent].
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [write_streams][crate::write::generated::gapic_storage::model::BatchCommitWriteStreamsRequest::write_streams].
    pub fn set_write_streams<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.write_streams = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

/// Response message for `BatchCommitWriteStreams`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BatchCommitWriteStreamsResponse {
    /// The time at which streams were committed in microseconds granularity.
    /// This field will only exist when there are no stream errors.
    /// **Note** if this field is not set, it means the commit was not successful.
    pub commit_time: std::option::Option<wkt::Timestamp>,

    /// Stream level error if commit failed. Only streams with error will be in
    /// the list.
    /// If empty, there is no error and all streams are committed successfully.
    /// If non empty, certain streams have errors and ZERO stream is committed due
    /// to atomicity guarantee.
    pub stream_errors: std::vec::Vec<crate::write::generated::gapic_storage::model::StorageError>,

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

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

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

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

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

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

/// Request message for invoking `FinalizeWriteStream`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FinalizeWriteStreamRequest {
    /// Required. Name of the stream to finalize, in the form of
    /// `projects/{project}/datasets/{dataset}/tables/{table}/streams/{stream}`.
    pub name: std::string::String,

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

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

    /// Sets the value of [name][crate::write::generated::gapic_storage::model::FinalizeWriteStreamRequest::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 FinalizeWriteStreamRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.storage.v1.FinalizeWriteStreamRequest"
    }
}

/// Response message for `FinalizeWriteStream`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FinalizeWriteStreamResponse {
    /// Number of rows in the finalized stream.
    pub row_count: i64,

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

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

    /// Sets the value of [row_count][crate::write::generated::gapic_storage::model::FinalizeWriteStreamResponse::row_count].
    pub fn set_row_count<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.row_count = v.into();
        self
    }
}

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

/// Request message for `FlushRows`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FlushRowsRequest {
    /// Required. The stream that is the target of the flush operation.
    pub write_stream: std::string::String,

    /// Ending offset of the flush operation. Rows before this offset(including
    /// this offset) will be flushed.
    pub offset: std::option::Option<wkt::Int64Value>,

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

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

    /// Sets the value of [write_stream][crate::write::generated::gapic_storage::model::FlushRowsRequest::write_stream].
    pub fn set_write_stream<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.write_stream = v.into();
        self
    }

    /// Sets the value of [offset][crate::write::generated::gapic_storage::model::FlushRowsRequest::offset].
    pub fn set_offset<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Int64Value>,
    {
        self.offset = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [offset][crate::write::generated::gapic_storage::model::FlushRowsRequest::offset].
    pub fn set_or_clear_offset<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Int64Value>,
    {
        self.offset = v.map(|x| x.into());
        self
    }
}

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

/// Respond message for `FlushRows`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FlushRowsResponse {
    /// The rows before this offset (including this offset) are flushed.
    pub offset: i64,

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

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

    /// Sets the value of [offset][crate::write::generated::gapic_storage::model::FlushRowsResponse::offset].
    pub fn set_offset<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.offset = v.into();
        self
    }
}

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

/// Structured custom BigQuery Storage error message. The error can be attached
/// as error details in the returned rpc Status. In particular, the use of error
/// codes allows more structured error handling, and reduces the need to evaluate
/// unstructured error text strings.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StorageError {
    /// BigQuery Storage specific error code.
    pub code: crate::write::generated::gapic_storage::model::storage_error::StorageErrorCode,

    /// Name of the failed entity.
    pub entity: std::string::String,

    /// Message that describes the error.
    pub error_message: std::string::String,

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

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

    /// Sets the value of [code][crate::write::generated::gapic_storage::model::StorageError::code].
    pub fn set_code<
        T: std::convert::Into<
                crate::write::generated::gapic_storage::model::storage_error::StorageErrorCode,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.code = v.into();
        self
    }

    /// Sets the value of [entity][crate::write::generated::gapic_storage::model::StorageError::entity].
    pub fn set_entity<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.entity = v.into();
        self
    }

    /// Sets the value of [error_message][crate::write::generated::gapic_storage::model::StorageError::error_message].
    pub fn set_error_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.error_message = v.into();
        self
    }
}

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

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

    /// Error code for `StorageError`.
    ///
    /// # 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 StorageErrorCode {
        /// Default error.
        Unspecified,
        /// Table is not found in the system.
        TableNotFound,
        /// Stream is already committed.
        StreamAlreadyCommitted,
        /// Stream is not found.
        StreamNotFound,
        /// Invalid Stream type.
        /// For example, you try to commit a stream that is not pending.
        InvalidStreamType,
        /// Invalid Stream state.
        /// For example, you try to commit a stream that is not finalized or is
        /// garbaged.
        InvalidStreamState,
        /// Stream is finalized.
        StreamFinalized,
        /// There is a schema mismatch and it is caused by user schema has extra
        /// field than bigquery schema.
        SchemaMismatchExtraFields,
        /// Offset already exists.
        OffsetAlreadyExists,
        /// Offset out of range.
        OffsetOutOfRange,
        /// Customer-managed encryption key (CMEK) not provided for CMEK-enabled
        /// data.
        CmekNotProvided,
        /// Customer-managed encryption key (CMEK) was incorrectly provided.
        InvalidCmekProvided,
        /// There is an encryption error while using customer-managed encryption key.
        CmekEncryptionError,
        /// Key Management Service (KMS) service returned an error, which can be
        /// retried.
        KmsServiceError,
        /// Permission denied while using customer-managed encryption key.
        KmsPermissionDenied,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [StorageErrorCode::value] or
        /// [StorageErrorCode::name].
        UnknownValue(storage_error_code::UnknownValue),
    }

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

    impl StorageErrorCode {
        /// 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::TableNotFound => std::option::Option::Some(1),
                Self::StreamAlreadyCommitted => std::option::Option::Some(2),
                Self::StreamNotFound => std::option::Option::Some(3),
                Self::InvalidStreamType => std::option::Option::Some(4),
                Self::InvalidStreamState => std::option::Option::Some(5),
                Self::StreamFinalized => std::option::Option::Some(6),
                Self::SchemaMismatchExtraFields => std::option::Option::Some(7),
                Self::OffsetAlreadyExists => std::option::Option::Some(8),
                Self::OffsetOutOfRange => std::option::Option::Some(9),
                Self::CmekNotProvided => std::option::Option::Some(10),
                Self::InvalidCmekProvided => std::option::Option::Some(11),
                Self::CmekEncryptionError => std::option::Option::Some(12),
                Self::KmsServiceError => std::option::Option::Some(13),
                Self::KmsPermissionDenied => std::option::Option::Some(14),
                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("STORAGE_ERROR_CODE_UNSPECIFIED"),
                Self::TableNotFound => std::option::Option::Some("TABLE_NOT_FOUND"),
                Self::StreamAlreadyCommitted => {
                    std::option::Option::Some("STREAM_ALREADY_COMMITTED")
                }
                Self::StreamNotFound => std::option::Option::Some("STREAM_NOT_FOUND"),
                Self::InvalidStreamType => std::option::Option::Some("INVALID_STREAM_TYPE"),
                Self::InvalidStreamState => std::option::Option::Some("INVALID_STREAM_STATE"),
                Self::StreamFinalized => std::option::Option::Some("STREAM_FINALIZED"),
                Self::SchemaMismatchExtraFields => {
                    std::option::Option::Some("SCHEMA_MISMATCH_EXTRA_FIELDS")
                }
                Self::OffsetAlreadyExists => std::option::Option::Some("OFFSET_ALREADY_EXISTS"),
                Self::OffsetOutOfRange => std::option::Option::Some("OFFSET_OUT_OF_RANGE"),
                Self::CmekNotProvided => std::option::Option::Some("CMEK_NOT_PROVIDED"),
                Self::InvalidCmekProvided => std::option::Option::Some("INVALID_CMEK_PROVIDED"),
                Self::CmekEncryptionError => std::option::Option::Some("CMEK_ENCRYPTION_ERROR"),
                Self::KmsServiceError => std::option::Option::Some("KMS_SERVICE_ERROR"),
                Self::KmsPermissionDenied => std::option::Option::Some("KMS_PERMISSION_DENIED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

    impl std::fmt::Display for StorageErrorCode {
        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 StorageErrorCode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::TableNotFound,
                2 => Self::StreamAlreadyCommitted,
                3 => Self::StreamNotFound,
                4 => Self::InvalidStreamType,
                5 => Self::InvalidStreamState,
                6 => Self::StreamFinalized,
                7 => Self::SchemaMismatchExtraFields,
                8 => Self::OffsetAlreadyExists,
                9 => Self::OffsetOutOfRange,
                10 => Self::CmekNotProvided,
                11 => Self::InvalidCmekProvided,
                12 => Self::CmekEncryptionError,
                13 => Self::KmsServiceError,
                14 => Self::KmsPermissionDenied,
                _ => Self::UnknownValue(storage_error_code::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for StorageErrorCode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "STORAGE_ERROR_CODE_UNSPECIFIED" => Self::Unspecified,
                "TABLE_NOT_FOUND" => Self::TableNotFound,
                "STREAM_ALREADY_COMMITTED" => Self::StreamAlreadyCommitted,
                "STREAM_NOT_FOUND" => Self::StreamNotFound,
                "INVALID_STREAM_TYPE" => Self::InvalidStreamType,
                "INVALID_STREAM_STATE" => Self::InvalidStreamState,
                "STREAM_FINALIZED" => Self::StreamFinalized,
                "SCHEMA_MISMATCH_EXTRA_FIELDS" => Self::SchemaMismatchExtraFields,
                "OFFSET_ALREADY_EXISTS" => Self::OffsetAlreadyExists,
                "OFFSET_OUT_OF_RANGE" => Self::OffsetOutOfRange,
                "CMEK_NOT_PROVIDED" => Self::CmekNotProvided,
                "INVALID_CMEK_PROVIDED" => Self::InvalidCmekProvided,
                "CMEK_ENCRYPTION_ERROR" => Self::CmekEncryptionError,
                "KMS_SERVICE_ERROR" => Self::KmsServiceError,
                "KMS_PERMISSION_DENIED" => Self::KmsPermissionDenied,
                _ => Self::UnknownValue(storage_error_code::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for StorageErrorCode {
        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::TableNotFound => serializer.serialize_i32(1),
                Self::StreamAlreadyCommitted => serializer.serialize_i32(2),
                Self::StreamNotFound => serializer.serialize_i32(3),
                Self::InvalidStreamType => serializer.serialize_i32(4),
                Self::InvalidStreamState => serializer.serialize_i32(5),
                Self::StreamFinalized => serializer.serialize_i32(6),
                Self::SchemaMismatchExtraFields => serializer.serialize_i32(7),
                Self::OffsetAlreadyExists => serializer.serialize_i32(8),
                Self::OffsetOutOfRange => serializer.serialize_i32(9),
                Self::CmekNotProvided => serializer.serialize_i32(10),
                Self::InvalidCmekProvided => serializer.serialize_i32(11),
                Self::CmekEncryptionError => serializer.serialize_i32(12),
                Self::KmsServiceError => serializer.serialize_i32(13),
                Self::KmsPermissionDenied => serializer.serialize_i32(14),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// The message that presents row level error info in a request.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RowError {
    /// Index of the malformed row in the request.
    pub index: i64,

    /// Structured error reason for a row error.
    pub code: crate::write::generated::gapic_storage::model::row_error::RowErrorCode,

    /// Description of the issue encountered when processing the row.
    pub message: std::string::String,

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

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

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

    /// Sets the value of [code][crate::write::generated::gapic_storage::model::RowError::code].
    pub fn set_code<
        T: std::convert::Into<crate::write::generated::gapic_storage::model::row_error::RowErrorCode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.code = v.into();
        self
    }

    /// Sets the value of [message][crate::write::generated::gapic_storage::model::RowError::message].
    pub fn set_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.message = v.into();
        self
    }
}

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

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

    /// Error code for `RowError`.
    ///
    /// # 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 RowErrorCode {
        /// Default error.
        Unspecified,
        /// One or more fields in the row has errors.
        FieldsError,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [RowErrorCode::value] or
        /// [RowErrorCode::name].
        UnknownValue(row_error_code::UnknownValue),
    }

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

    impl RowErrorCode {
        /// 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::FieldsError => std::option::Option::Some(1),
                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("ROW_ERROR_CODE_UNSPECIFIED"),
                Self::FieldsError => std::option::Option::Some("FIELDS_ERROR"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

    impl std::fmt::Display for RowErrorCode {
        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 RowErrorCode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::FieldsError,
                _ => Self::UnknownValue(row_error_code::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for RowErrorCode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "ROW_ERROR_CODE_UNSPECIFIED" => Self::Unspecified,
                "FIELDS_ERROR" => Self::FieldsError,
                _ => Self::UnknownValue(row_error_code::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for RowErrorCode {
        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::FieldsError => serializer.serialize_i32(1),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// Stats and telemetry data gathered on the client side about requests
/// being sent to the BigQuery Storage service, for internal use only.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ClientStats {
    /// Optional. Per-request stats.
    pub request_stats: std::option::Option<
        crate::write::generated::gapic_storage::model::client_stats::RequestStats,
    >,

    /// Optional. Windowed stats.
    pub window_stats: std::option::Option<
        crate::write::generated::gapic_storage::model::client_stats::WindowStats,
    >,

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

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

    /// Sets the value of [request_stats][crate::write::generated::gapic_storage::model::ClientStats::request_stats].
    pub fn set_request_stats<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<
                crate::write::generated::gapic_storage::model::client_stats::RequestStats,
            >,
    {
        self.request_stats = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [request_stats][crate::write::generated::gapic_storage::model::ClientStats::request_stats].
    pub fn set_or_clear_request_stats<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<
                crate::write::generated::gapic_storage::model::client_stats::RequestStats,
            >,
    {
        self.request_stats = v.map(|x| x.into());
        self
    }

    /// Sets the value of [window_stats][crate::write::generated::gapic_storage::model::ClientStats::window_stats].
    pub fn set_window_stats<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<
                crate::write::generated::gapic_storage::model::client_stats::WindowStats,
            >,
    {
        self.window_stats = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [window_stats][crate::write::generated::gapic_storage::model::ClientStats::window_stats].
    pub fn set_or_clear_window_stats<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<
                crate::write::generated::gapic_storage::model::client_stats::WindowStats,
            >,
    {
        self.window_stats = v.map(|x| x.into());
        self
    }
}

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

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

    /// Stats and telemetry data gathered on the client side about a single
    /// request.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct RequestStats {
        /// Optional. Timestamp indicating when the request was sent over the
        /// network, expressed in epoch milliseconds.
        pub send_time_millis: std::option::Option<i64>,

        /// Optional. Number of pending requests at the moment this request was sent.
        /// This includes requests waiting to be sent, and those that are inflight.
        pub queued_requests_count: std::option::Option<i64>,

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

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

        /// Sets the value of [send_time_millis][crate::write::generated::gapic_storage::model::client_stats::RequestStats::send_time_millis].
        pub fn set_send_time_millis<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.send_time_millis = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [send_time_millis][crate::write::generated::gapic_storage::model::client_stats::RequestStats::send_time_millis].
        pub fn set_or_clear_send_time_millis<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.send_time_millis = v.map(|x| x.into());
            self
        }

        /// Sets the value of [queued_requests_count][crate::write::generated::gapic_storage::model::client_stats::RequestStats::queued_requests_count].
        pub fn set_queued_requests_count<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.queued_requests_count = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [queued_requests_count][crate::write::generated::gapic_storage::model::client_stats::RequestStats::queued_requests_count].
        pub fn set_or_clear_queued_requests_count<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.queued_requests_count = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for RequestStats {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.bigquery.storage.v1.ClientStats.RequestStats"
        }
    }

    /// Aggregate connection metrics over a window interval.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct WindowStats {
        /// Optional. The maximum response latency observed in the window, expressed
        /// in milliseconds.
        pub max_response_latency_millis: std::option::Option<i64>,

        /// Optional. The average response latency observed in the window, expressed
        /// in milliseconds.
        pub avg_response_latency_millis: std::option::Option<i64>,

        /// Optional. The longest time spent waiting without receiving a response in
        /// the window. This could exceed max_response_latency_millis because the
        /// latter is evaluated only when a response is received. Expressed in
        /// milliseconds.
        pub longest_wait_no_response_millis: std::option::Option<i64>,

        /// Optional. How many requests were sent in the window.
        pub requests_sent_count: std::option::Option<i64>,

        /// Optional. How many responses were received in the window.
        pub responses_received_count: std::option::Option<i64>,

        /// Optional. How many bytes were sent in the window.
        pub bytes_sent_count: std::option::Option<i64>,

        /// Optional. Start time of the window interval for which these stats are
        /// aggregated, expressed in epoch milliseconds.
        pub window_start_time_epoch_millis: std::option::Option<i64>,

        /// Optional. Duration of the window interval for which these stats are
        /// aggregated, expressed in milliseconds.
        pub window_millis: std::option::Option<i64>,

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

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

        /// Sets the value of [max_response_latency_millis][crate::write::generated::gapic_storage::model::client_stats::WindowStats::max_response_latency_millis].
        pub fn set_max_response_latency_millis<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.max_response_latency_millis = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [max_response_latency_millis][crate::write::generated::gapic_storage::model::client_stats::WindowStats::max_response_latency_millis].
        pub fn set_or_clear_max_response_latency_millis<T>(
            mut self,
            v: std::option::Option<T>,
        ) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.max_response_latency_millis = v.map(|x| x.into());
            self
        }

        /// Sets the value of [avg_response_latency_millis][crate::write::generated::gapic_storage::model::client_stats::WindowStats::avg_response_latency_millis].
        pub fn set_avg_response_latency_millis<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.avg_response_latency_millis = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [avg_response_latency_millis][crate::write::generated::gapic_storage::model::client_stats::WindowStats::avg_response_latency_millis].
        pub fn set_or_clear_avg_response_latency_millis<T>(
            mut self,
            v: std::option::Option<T>,
        ) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.avg_response_latency_millis = v.map(|x| x.into());
            self
        }

        /// Sets the value of [longest_wait_no_response_millis][crate::write::generated::gapic_storage::model::client_stats::WindowStats::longest_wait_no_response_millis].
        pub fn set_longest_wait_no_response_millis<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.longest_wait_no_response_millis = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [longest_wait_no_response_millis][crate::write::generated::gapic_storage::model::client_stats::WindowStats::longest_wait_no_response_millis].
        pub fn set_or_clear_longest_wait_no_response_millis<T>(
            mut self,
            v: std::option::Option<T>,
        ) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.longest_wait_no_response_millis = v.map(|x| x.into());
            self
        }

        /// Sets the value of [requests_sent_count][crate::write::generated::gapic_storage::model::client_stats::WindowStats::requests_sent_count].
        pub fn set_requests_sent_count<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.requests_sent_count = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [requests_sent_count][crate::write::generated::gapic_storage::model::client_stats::WindowStats::requests_sent_count].
        pub fn set_or_clear_requests_sent_count<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.requests_sent_count = v.map(|x| x.into());
            self
        }

        /// Sets the value of [responses_received_count][crate::write::generated::gapic_storage::model::client_stats::WindowStats::responses_received_count].
        pub fn set_responses_received_count<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.responses_received_count = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [responses_received_count][crate::write::generated::gapic_storage::model::client_stats::WindowStats::responses_received_count].
        pub fn set_or_clear_responses_received_count<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.responses_received_count = v.map(|x| x.into());
            self
        }

        /// Sets the value of [bytes_sent_count][crate::write::generated::gapic_storage::model::client_stats::WindowStats::bytes_sent_count].
        pub fn set_bytes_sent_count<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.bytes_sent_count = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [bytes_sent_count][crate::write::generated::gapic_storage::model::client_stats::WindowStats::bytes_sent_count].
        pub fn set_or_clear_bytes_sent_count<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.bytes_sent_count = v.map(|x| x.into());
            self
        }

        /// Sets the value of [window_start_time_epoch_millis][crate::write::generated::gapic_storage::model::client_stats::WindowStats::window_start_time_epoch_millis].
        pub fn set_window_start_time_epoch_millis<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.window_start_time_epoch_millis = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [window_start_time_epoch_millis][crate::write::generated::gapic_storage::model::client_stats::WindowStats::window_start_time_epoch_millis].
        pub fn set_or_clear_window_start_time_epoch_millis<T>(
            mut self,
            v: std::option::Option<T>,
        ) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.window_start_time_epoch_millis = v.map(|x| x.into());
            self
        }

        /// Sets the value of [window_millis][crate::write::generated::gapic_storage::model::client_stats::WindowStats::window_millis].
        pub fn set_window_millis<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.window_millis = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [window_millis][crate::write::generated::gapic_storage::model::client_stats::WindowStats::window_millis].
        pub fn set_or_clear_window_millis<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<i64>,
        {
            self.window_millis = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for WindowStats {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.bigquery.storage.v1.ClientStats.WindowStats"
        }
    }
}

/// Information about the ReadSession.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ReadSession {
    /// Output only. Unique identifier for the session, in the form
    /// `projects/{project_id}/locations/{location}/sessions/{session_id}`.
    pub name: std::string::String,

    /// Output only. Time at which the session becomes invalid. After this time,
    /// subsequent requests to read this Session will return errors. The
    /// expire_time is automatically assigned and currently cannot be specified or
    /// updated.
    pub expire_time: std::option::Option<wkt::Timestamp>,

    /// Immutable. Data format of the output data. DATA_FORMAT_UNSPECIFIED not
    /// supported.
    pub data_format: crate::write::generated::gapic_storage::model::DataFormat,

    /// Immutable. Table that this ReadSession is reading from, in the form
    /// `projects/{project_id}/datasets/{dataset_id}/tables/{table_id}`
    pub table: std::string::String,

    /// Optional. Any modifiers which are applied when reading from the specified
    /// table.
    pub table_modifiers: std::option::Option<
        crate::write::generated::gapic_storage::model::read_session::TableModifiers,
    >,

    /// Optional. Read options for this session (e.g. column selection, filters).
    pub read_options: std::option::Option<
        crate::write::generated::gapic_storage::model::read_session::TableReadOptions,
    >,

    /// Output only. A list of streams created with the session.
    ///
    /// At least one stream is created with the session. In the future, larger
    /// request_stream_count values *may* result in this list being unpopulated,
    /// in that case, the user will need to use a List method to get the streams
    /// instead, which is not yet available.
    pub streams: std::vec::Vec<crate::write::generated::gapic_storage::model::ReadStream>,

    /// Output only. An estimate on the number of bytes this session will scan when
    /// all streams are completely consumed. This estimate is based on
    /// metadata from the table which might be incomplete or stale.
    pub estimated_total_bytes_scanned: i64,

    /// Output only. A pre-projected estimate of the total physical size of files
    /// (in bytes) that this session will scan when all streams are consumed. This
    /// estimate is independent of the selected columns and can be based on
    /// incomplete or stale metadata from the table.  This field is only set for
    /// BigLake tables.
    pub estimated_total_physical_file_size: i64,

    /// Output only. An estimate on the number of rows present in this session's
    /// streams. This estimate is based on metadata from the table which might be
    /// incomplete or stale.
    pub estimated_row_count: i64,

    /// Optional. ID set by client to annotate a session identity.  This does not
    /// need to be strictly unique, but instead the same ID should be used to group
    /// logically connected sessions (e.g. All using the same ID for all sessions
    /// needed to complete a Spark SQL query is reasonable).
    ///
    /// Maximum length is 256 bytes.
    pub trace_id: std::string::String,

    /// The schema for the read. If read_options.selected_fields is set, the
    /// schema may be different from the table schema as it will only contain
    /// the selected fields.
    pub schema:
        std::option::Option<crate::write::generated::gapic_storage::model::read_session::Schema>,

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

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

    /// Sets the value of [name][crate::write::generated::gapic_storage::model::ReadSession::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 [expire_time][crate::write::generated::gapic_storage::model::ReadSession::expire_time].
    pub fn set_expire_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.expire_time = std::option::Option::Some(v.into());
        self
    }

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

    /// Sets the value of [data_format][crate::write::generated::gapic_storage::model::ReadSession::data_format].
    pub fn set_data_format<
        T: std::convert::Into<crate::write::generated::gapic_storage::model::DataFormat>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.data_format = v.into();
        self
    }

    /// Sets the value of [table][crate::write::generated::gapic_storage::model::ReadSession::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 [table_modifiers][crate::write::generated::gapic_storage::model::ReadSession::table_modifiers].
    pub fn set_table_modifiers<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<
                crate::write::generated::gapic_storage::model::read_session::TableModifiers,
            >,
    {
        self.table_modifiers = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [table_modifiers][crate::write::generated::gapic_storage::model::ReadSession::table_modifiers].
    pub fn set_or_clear_table_modifiers<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<
                crate::write::generated::gapic_storage::model::read_session::TableModifiers,
            >,
    {
        self.table_modifiers = v.map(|x| x.into());
        self
    }

    /// Sets the value of [read_options][crate::write::generated::gapic_storage::model::ReadSession::read_options].
    pub fn set_read_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<
                crate::write::generated::gapic_storage::model::read_session::TableReadOptions,
            >,
    {
        self.read_options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [read_options][crate::write::generated::gapic_storage::model::ReadSession::read_options].
    pub fn set_or_clear_read_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<
                crate::write::generated::gapic_storage::model::read_session::TableReadOptions,
            >,
    {
        self.read_options = v.map(|x| x.into());
        self
    }

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

    /// Sets the value of [estimated_total_bytes_scanned][crate::write::generated::gapic_storage::model::ReadSession::estimated_total_bytes_scanned].
    pub fn set_estimated_total_bytes_scanned<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.estimated_total_bytes_scanned = v.into();
        self
    }

    /// Sets the value of [estimated_total_physical_file_size][crate::write::generated::gapic_storage::model::ReadSession::estimated_total_physical_file_size].
    pub fn set_estimated_total_physical_file_size<T: std::convert::Into<i64>>(
        mut self,
        v: T,
    ) -> Self {
        self.estimated_total_physical_file_size = v.into();
        self
    }

    /// Sets the value of [estimated_row_count][crate::write::generated::gapic_storage::model::ReadSession::estimated_row_count].
    pub fn set_estimated_row_count<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.estimated_row_count = v.into();
        self
    }

    /// Sets the value of [trace_id][crate::write::generated::gapic_storage::model::ReadSession::trace_id].
    pub fn set_trace_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.trace_id = v.into();
        self
    }

    /// Sets the value of [schema][crate::write::generated::gapic_storage::model::ReadSession::schema].
    ///
    /// Note that all the setters affecting `schema` are mutually
    /// exclusive.
    pub fn set_schema<
        T: std::convert::Into<
                std::option::Option<
                    crate::write::generated::gapic_storage::model::read_session::Schema,
                >,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.schema = v.into();
        self
    }

    /// The value of [schema][crate::write::generated::gapic_storage::model::ReadSession::schema]
    /// if it holds a `AvroSchema`, `None` if the field is not set or
    /// holds a different branch.
    pub fn avro_schema(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::write::generated::gapic_storage::model::AvroSchema>,
    > {
        #[allow(unreachable_patterns)]
        self.schema.as_ref().and_then(|v| match v {
            crate::write::generated::gapic_storage::model::read_session::Schema::AvroSchema(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [schema][crate::write::generated::gapic_storage::model::ReadSession::schema]
    /// to hold a `AvroSchema`.
    ///
    /// Note that all the setters affecting `schema` are
    /// mutually exclusive.
    pub fn set_avro_schema<
        T: std::convert::Into<
                std::boxed::Box<crate::write::generated::gapic_storage::model::AvroSchema>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.schema = std::option::Option::Some(
            crate::write::generated::gapic_storage::model::read_session::Schema::AvroSchema(
                v.into(),
            ),
        );
        self
    }

    /// The value of [schema][crate::write::generated::gapic_storage::model::ReadSession::schema]
    /// if it holds a `ArrowSchema`, `None` if the field is not set or
    /// holds a different branch.
    pub fn arrow_schema(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::write::generated::gapic_storage::model::ArrowSchema>,
    > {
        #[allow(unreachable_patterns)]
        self.schema.as_ref().and_then(|v| match v {
            crate::write::generated::gapic_storage::model::read_session::Schema::ArrowSchema(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [schema][crate::write::generated::gapic_storage::model::ReadSession::schema]
    /// to hold a `ArrowSchema`.
    ///
    /// Note that all the setters affecting `schema` are
    /// mutually exclusive.
    pub fn set_arrow_schema<
        T: std::convert::Into<
                std::boxed::Box<crate::write::generated::gapic_storage::model::ArrowSchema>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.schema = std::option::Option::Some(
            crate::write::generated::gapic_storage::model::read_session::Schema::ArrowSchema(
                v.into(),
            ),
        );
        self
    }
}

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

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

    /// Additional attributes when reading a table.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct TableModifiers {
        /// The snapshot time of the table. If not set, interpreted as now.
        pub snapshot_time: std::option::Option<wkt::Timestamp>,

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

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

        /// Sets the value of [snapshot_time][crate::write::generated::gapic_storage::model::read_session::TableModifiers::snapshot_time].
        pub fn set_snapshot_time<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.snapshot_time = std::option::Option::Some(v.into());
            self
        }

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

    impl wkt::message::Message for TableModifiers {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.bigquery.storage.v1.ReadSession.TableModifiers"
        }
    }

    /// Options dictating how we read a table.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct TableReadOptions {

        /// Optional. The names of the fields in the table to be returned. If no
        /// field names are specified, then all fields in the table are returned.
        ///
        /// Nested fields -- the child elements of a STRUCT field -- can be selected
        /// individually using their fully-qualified names, and will be returned as
        /// record fields containing only the selected nested fields. If a STRUCT
        /// field is specified in the selected fields list, all of the child elements
        /// will be returned.
        ///
        /// As an example, consider a table with the following schema:
        ///
        /// {
        /// "name": "struct_field",
        /// "type": "RECORD",
        /// "mode": "NULLABLE",
        /// "fields": [
        /// {
        /// "name": "string_field1",
        /// "type": "STRING",
        /// .              "mode": "NULLABLE"
        /// },
        /// {
        /// "name": "string_field2",
        /// "type": "STRING",
        /// "mode": "NULLABLE"
        /// }
        /// ]
        /// }
        ///
        /// Specifying "struct_field" in the selected fields list will result in a
        /// read session schema with the following logical structure:
        ///
        /// struct_field {
        /// string_field1
        /// string_field2
        /// }
        ///
        /// Specifying "struct_field.string_field1" in the selected fields list will
        /// result in a read session schema with the following logical structure:
        ///
        /// struct_field {
        /// string_field1
        /// }
        ///
        /// The order of the fields in the read session schema is derived from the
        /// table schema and does not correspond to the order in which the fields are
        /// specified in this list.
        pub selected_fields: std::vec::Vec<std::string::String>,

        /// SQL text filtering statement, similar to a WHERE clause in a query.
        /// Aggregates are not supported.
        ///
        /// Examples: "int_field > 5"
        /// "date_field = CAST('2014-9-27' as DATE)"
        /// "nullable_field is not NULL"
        /// "st_equals(geo_field, st_geofromtext("POINT(2, 2)"))"
        /// "numeric_field BETWEEN 1.0 AND 5.0"
        ///
        /// Restricted to a maximum length for 1 MB.
        pub row_restriction: std::string::String,

        /// Optional. Specifies a table sampling percentage. Specifically, the query
        /// planner will use TABLESAMPLE SYSTEM (sample_percentage PERCENT). The
        /// sampling percentage is applied at the data block granularity. It will
        /// randomly choose for each data block whether to read the rows in that data
        /// block. For more details, see
        /// <https://cloud.google.com/bigquery/docs/table-sampling>)
        pub sample_percentage: std::option::Option<f64>,

        /// Optional. Set response_compression_codec when creating a read session to
        /// enable application-level compression of ReadRows responses.
        pub response_compression_codec: std::option::Option<crate::write::generated::gapic_storage::model::read_session::table_read_options::ResponseCompressionCodec>,

        #[allow(missing_docs)]
        pub output_format_serialization_options: std::option::Option<crate::write::generated::gapic_storage::model::read_session::table_read_options::OutputFormatSerializationOptions>,

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

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

        /// Sets the value of [selected_fields][crate::write::generated::gapic_storage::model::read_session::TableReadOptions::selected_fields].
        pub fn set_selected_fields<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.selected_fields = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [row_restriction][crate::write::generated::gapic_storage::model::read_session::TableReadOptions::row_restriction].
        pub fn set_row_restriction<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.row_restriction = v.into();
            self
        }

        /// Sets the value of [sample_percentage][crate::write::generated::gapic_storage::model::read_session::TableReadOptions::sample_percentage].
        pub fn set_sample_percentage<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<f64>,
        {
            self.sample_percentage = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [sample_percentage][crate::write::generated::gapic_storage::model::read_session::TableReadOptions::sample_percentage].
        pub fn set_or_clear_sample_percentage<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<f64>,
        {
            self.sample_percentage = v.map(|x| x.into());
            self
        }

        /// Sets the value of [response_compression_codec][crate::write::generated::gapic_storage::model::read_session::TableReadOptions::response_compression_codec].
        pub fn set_response_compression_codec<T>(mut self, v: T) -> Self
        where T: std::convert::Into<crate::write::generated::gapic_storage::model::read_session::table_read_options::ResponseCompressionCodec>
        {
            self.response_compression_codec = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [response_compression_codec][crate::write::generated::gapic_storage::model::read_session::TableReadOptions::response_compression_codec].
        pub fn set_or_clear_response_compression_codec<T>(mut self, v: std::option::Option<T>) -> Self
        where T: std::convert::Into<crate::write::generated::gapic_storage::model::read_session::table_read_options::ResponseCompressionCodec>
        {
            self.response_compression_codec = v.map(|x| x.into());
            self
        }

        /// Sets the value of [output_format_serialization_options][crate::write::generated::gapic_storage::model::read_session::TableReadOptions::output_format_serialization_options].
        ///
        /// Note that all the setters affecting `output_format_serialization_options` are mutually
        /// exclusive.
        pub fn set_output_format_serialization_options<T: std::convert::Into<std::option::Option<crate::write::generated::gapic_storage::model::read_session::table_read_options::OutputFormatSerializationOptions>>>(mut self, v: T) -> Self
        {
            self.output_format_serialization_options = v.into();
            self
        }

        /// The value of [output_format_serialization_options][crate::write::generated::gapic_storage::model::read_session::TableReadOptions::output_format_serialization_options]
        /// if it holds a `ArrowSerializationOptions`, `None` if the field is not set or
        /// holds a different branch.
        pub fn arrow_serialization_options(
            &self,
        ) -> std::option::Option<
            &std::boxed::Box<
                crate::write::generated::gapic_storage::model::ArrowSerializationOptions,
            >,
        > {
            #[allow(unreachable_patterns)]
            self.output_format_serialization_options.as_ref().and_then(|v| match v {
                crate::write::generated::gapic_storage::model::read_session::table_read_options::OutputFormatSerializationOptions::ArrowSerializationOptions(v) => std::option::Option::Some(v),
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [output_format_serialization_options][crate::write::generated::gapic_storage::model::read_session::TableReadOptions::output_format_serialization_options]
        /// to hold a `ArrowSerializationOptions`.
        ///
        /// Note that all the setters affecting `output_format_serialization_options` are
        /// mutually exclusive.
        pub fn set_arrow_serialization_options<
            T: std::convert::Into<
                    std::boxed::Box<
                        crate::write::generated::gapic_storage::model::ArrowSerializationOptions,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.output_format_serialization_options = std::option::Option::Some(
                crate::write::generated::gapic_storage::model::read_session::table_read_options::OutputFormatSerializationOptions::ArrowSerializationOptions(
                    v.into()
                )
            );
            self
        }

        /// The value of [output_format_serialization_options][crate::write::generated::gapic_storage::model::read_session::TableReadOptions::output_format_serialization_options]
        /// if it holds a `AvroSerializationOptions`, `None` if the field is not set or
        /// holds a different branch.
        pub fn avro_serialization_options(
            &self,
        ) -> std::option::Option<
            &std::boxed::Box<
                crate::write::generated::gapic_storage::model::AvroSerializationOptions,
            >,
        > {
            #[allow(unreachable_patterns)]
            self.output_format_serialization_options.as_ref().and_then(|v| match v {
                crate::write::generated::gapic_storage::model::read_session::table_read_options::OutputFormatSerializationOptions::AvroSerializationOptions(v) => std::option::Option::Some(v),
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [output_format_serialization_options][crate::write::generated::gapic_storage::model::read_session::TableReadOptions::output_format_serialization_options]
        /// to hold a `AvroSerializationOptions`.
        ///
        /// Note that all the setters affecting `output_format_serialization_options` are
        /// mutually exclusive.
        pub fn set_avro_serialization_options<
            T: std::convert::Into<
                    std::boxed::Box<
                        crate::write::generated::gapic_storage::model::AvroSerializationOptions,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.output_format_serialization_options = std::option::Option::Some(
                crate::write::generated::gapic_storage::model::read_session::table_read_options::OutputFormatSerializationOptions::AvroSerializationOptions(
                    v.into()
                )
            );
            self
        }
    }

    impl wkt::message::Message for TableReadOptions {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.bigquery.storage.v1.ReadSession.TableReadOptions"
        }
    }

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

        /// Specifies which compression codec to attempt on the entire serialized
        /// response payload (either Arrow record batch or Avro rows). This is
        /// not to be confused with the Apache Arrow native compression codecs
        /// specified in ArrowSerializationOptions. For performance reasons, when
        /// creating a read session requesting Arrow responses, setting both native
        /// Arrow compression and application-level response compression will not be
        /// allowed - choose, at most, one kind of compression.
        ///
        /// # 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 ResponseCompressionCodec {
            /// Default is no compression.
            Unspecified,
            /// Use raw LZ4 compression.
            Lz4,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [ResponseCompressionCodec::value] or
            /// [ResponseCompressionCodec::name].
            UnknownValue(response_compression_codec::UnknownValue),
        }

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

        impl ResponseCompressionCodec {
            /// 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::Lz4 => 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("RESPONSE_COMPRESSION_CODEC_UNSPECIFIED")
                    }
                    Self::Lz4 => std::option::Option::Some("RESPONSE_COMPRESSION_CODEC_LZ4"),
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

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

        impl std::fmt::Display for ResponseCompressionCodec {
            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 ResponseCompressionCodec {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    2 => Self::Lz4,
                    _ => Self::UnknownValue(response_compression_codec::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for ResponseCompressionCodec {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "RESPONSE_COMPRESSION_CODEC_UNSPECIFIED" => Self::Unspecified,
                    "RESPONSE_COMPRESSION_CODEC_LZ4" => Self::Lz4,
                    _ => Self::UnknownValue(response_compression_codec::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for ResponseCompressionCodec {
            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::Lz4 => serializer.serialize_i32(2),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for ResponseCompressionCodec {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<ResponseCompressionCodec>::new(
                    ".google.cloud.bigquery.storage.v1.ReadSession.TableReadOptions.ResponseCompressionCodec"))
            }
        }

        #[allow(missing_docs)]
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum OutputFormatSerializationOptions {
            /// Optional. Options specific to the Apache Arrow output format.
            ArrowSerializationOptions(
                std::boxed::Box<
                    crate::write::generated::gapic_storage::model::ArrowSerializationOptions,
                >,
            ),
            /// Optional. Options specific to the Apache Avro output format
            AvroSerializationOptions(
                std::boxed::Box<
                    crate::write::generated::gapic_storage::model::AvroSerializationOptions,
                >,
            ),
        }

        impl OutputFormatSerializationOptions {
            /// Initializes the enum to the [ArrowSerializationOptions](Self::ArrowSerializationOptions) branch.
            pub fn from_arrow_serialization_options(
                value: impl std::convert::Into<
                    std::boxed::Box<
                        crate::write::generated::gapic_storage::model::ArrowSerializationOptions,
                    >,
                >,
            ) -> Self {
                Self::ArrowSerializationOptions(value.into())
            }
            /// Initializes the enum to the [AvroSerializationOptions](Self::AvroSerializationOptions) branch.
            pub fn from_avro_serialization_options(
                value: impl std::convert::Into<
                    std::boxed::Box<
                        crate::write::generated::gapic_storage::model::AvroSerializationOptions,
                    >,
                >,
            ) -> Self {
                Self::AvroSerializationOptions(value.into())
            }
        }
    }

    /// The schema for the read. If read_options.selected_fields is set, the
    /// schema may be different from the table schema as it will only contain
    /// the selected fields.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Schema {
        /// Output only. Avro schema.
        AvroSchema(std::boxed::Box<crate::write::generated::gapic_storage::model::AvroSchema>),
        /// Output only. Arrow schema.
        ArrowSchema(std::boxed::Box<crate::write::generated::gapic_storage::model::ArrowSchema>),
    }

    impl Schema {
        /// Initializes the enum to the [AvroSchema](Self::AvroSchema) branch.
        pub fn from_avro_schema(
            value: impl std::convert::Into<
                std::boxed::Box<crate::write::generated::gapic_storage::model::AvroSchema>,
            >,
        ) -> Self {
            Self::AvroSchema(value.into())
        }
        /// Initializes the enum to the [ArrowSchema](Self::ArrowSchema) branch.
        pub fn from_arrow_schema(
            value: impl std::convert::Into<
                std::boxed::Box<crate::write::generated::gapic_storage::model::ArrowSchema>,
            >,
        ) -> Self {
            Self::ArrowSchema(value.into())
        }
    }
}

/// Information about a single stream that gets data out of the storage system.
/// Most of the information about `ReadStream` instances is aggregated, making
/// `ReadStream` lightweight.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ReadStream {
    /// Output only. Name of the stream, in the form
    /// `projects/{project_id}/locations/{location}/sessions/{session_id}/streams/{stream_id}`.
    pub name: std::string::String,

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

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

    /// Sets the value of [name][crate::write::generated::gapic_storage::model::ReadStream::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 ReadStream {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.bigquery.storage.v1.ReadStream"
    }
}

/// Information about a single stream that gets data inside the storage system.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct WriteStream {
    /// Output only. Name of the stream, in the form
    /// `projects/{project}/datasets/{dataset}/tables/{table}/streams/{stream}`.
    pub name: std::string::String,

    /// Immutable. Type of the stream.
    pub r#type: crate::write::generated::gapic_storage::model::write_stream::Type,

    /// Output only. Create time of the stream. For the _default stream, this is
    /// the creation_time of the table.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Commit time of the stream.
    /// If a stream is of `COMMITTED` type, then it will have a commit_time same as
    /// `create_time`. If the stream is of `PENDING` type, empty commit_time
    /// means it is not committed.
    pub commit_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The schema of the destination table. It is only returned in
    /// `CreateWriteStream` response. Caller should generate data that's
    /// compatible with this schema to send in initial `AppendRowsRequest`.
    /// The table schema could go out of date during the life time of the stream.
    pub table_schema:
        std::option::Option<crate::write::generated::gapic_storage::model::TableSchema>,

    /// Immutable. Mode of the stream.
    pub write_mode: crate::write::generated::gapic_storage::model::write_stream::WriteMode,

    /// Output only. The geographic location where the stream's dataset resides.
    /// See <https://cloud.google.com/bigquery/docs/locations> for supported
    /// locations.
    pub location: std::string::String,

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

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

    /// Sets the value of [name][crate::write::generated::gapic_storage::model::WriteStream::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::write::generated::gapic_storage::model::WriteStream::type].
    pub fn set_type<
        T: std::convert::Into<crate::write::generated::gapic_storage::model::write_stream::Type>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = v.into();
        self
    }

    /// Sets the value of [create_time][crate::write::generated::gapic_storage::model::WriteStream::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::write::generated::gapic_storage::model::WriteStream::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 [commit_time][crate::write::generated::gapic_storage::model::WriteStream::commit_time].
    pub fn set_commit_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.commit_time = std::option::Option::Some(v.into());
        self
    }

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

    /// Sets the value of [table_schema][crate::write::generated::gapic_storage::model::WriteStream::table_schema].
    pub fn set_table_schema<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::TableSchema>,
    {
        self.table_schema = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [table_schema][crate::write::generated::gapic_storage::model::WriteStream::table_schema].
    pub fn set_or_clear_table_schema<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::write::generated::gapic_storage::model::TableSchema>,
    {
        self.table_schema = v.map(|x| x.into());
        self
    }

    /// Sets the value of [write_mode][crate::write::generated::gapic_storage::model::WriteStream::write_mode].
    pub fn set_write_mode<
        T: std::convert::Into<crate::write::generated::gapic_storage::model::write_stream::WriteMode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.write_mode = v.into();
        self
    }

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

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

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

    /// Type enum of the stream.
    ///
    /// # 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 {
        /// Unknown type.
        Unspecified,
        /// Data will commit automatically and appear as soon as the write is
        /// acknowledged.
        Committed,
        /// Data is invisible until the stream is committed.
        Pending,
        /// Data is only visible up to the offset to which it was flushed.
        Buffered,
        /// 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::Committed => std::option::Option::Some(1),
                Self::Pending => std::option::Option::Some(2),
                Self::Buffered => 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("TYPE_UNSPECIFIED"),
                Self::Committed => std::option::Option::Some("COMMITTED"),
                Self::Pending => std::option::Option::Some("PENDING"),
                Self::Buffered => std::option::Option::Some("BUFFERED"),
                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::Committed,
                2 => Self::Pending,
                3 => Self::Buffered,
                _ => 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,
                "COMMITTED" => Self::Committed,
                "PENDING" => Self::Pending,
                "BUFFERED" => Self::Buffered,
                _ => 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::Committed => serializer.serialize_i32(1),
                Self::Pending => serializer.serialize_i32(2),
                Self::Buffered => serializer.serialize_i32(3),
                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.cloud.bigquery.storage.v1.WriteStream.Type",
            ))
        }
    }

    /// Mode enum of the stream.
    ///
    /// # 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 WriteMode {
        /// Unknown type.
        Unspecified,
        /// Insert new records into the table.
        /// It is the default value if customers do not specify it.
        Insert,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [WriteMode::value] or
        /// [WriteMode::name].
        UnknownValue(write_mode::UnknownValue),
    }

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

    impl WriteMode {
        /// 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(1),
                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("WRITE_MODE_UNSPECIFIED"),
                Self::Insert => std::option::Option::Some("INSERT"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

    impl std::fmt::Display for WriteMode {
        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 WriteMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Insert,
                _ => Self::UnknownValue(write_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for WriteMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "WRITE_MODE_UNSPECIFIED" => Self::Unspecified,
                "INSERT" => Self::Insert,
                _ => Self::UnknownValue(write_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for WriteMode {
        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(1),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// Schema of a table. This schema is a subset of
/// google.cloud.bigquery.v2.TableSchema containing information necessary to
/// generate valid message to write to BigQuery.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TableSchema {
    /// Describes the fields in a table.
    pub fields: std::vec::Vec<crate::write::generated::gapic_storage::model::TableFieldSchema>,

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

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

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

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

/// TableFieldSchema defines a single field/column within a table schema.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TableFieldSchema {
    /// Required. The field name. The name must contain only letters (a-z, A-Z),
    /// numbers (0-9), or underscores (_), and must start with a letter or
    /// underscore. The maximum length is 128 characters.
    pub name: std::string::String,

    /// Required. The field data type.
    pub r#type: crate::write::generated::gapic_storage::model::table_field_schema::Type,

    /// Optional. The field mode. The default value is NULLABLE.
    pub mode: crate::write::generated::gapic_storage::model::table_field_schema::Mode,

    /// Optional. Describes the nested schema fields if the type property is set to
    /// STRUCT.
    pub fields: std::vec::Vec<crate::write::generated::gapic_storage::model::TableFieldSchema>,

    /// Optional. The field description. The maximum length is 1,024 characters.
    pub description: std::string::String,

    /// Optional. Maximum length of values of this field for STRINGS or BYTES.
    ///
    /// If max_length is not specified, no maximum length constraint is imposed
    /// on this field.
    ///
    /// If type = "STRING", then max_length represents the maximum UTF-8
    /// length of strings in this field.
    ///
    /// If type = "BYTES", then max_length represents the maximum number of
    /// bytes in this field.
    ///
    /// It is invalid to set this field if type is not "STRING" or "BYTES".
    pub max_length: i64,

    /// Optional. Precision (maximum number of total digits in base 10) and scale
    /// (maximum number of digits in the fractional part in base 10) constraints
    /// for values of this field for NUMERIC or BIGNUMERIC.
    ///
    /// It is invalid to set precision or scale if type is not "NUMERIC" or
    /// "BIGNUMERIC".
    ///
    /// If precision and scale are not specified, no value range constraint is
    /// imposed on this field insofar as values are permitted by the type.
    ///
    /// Values of this NUMERIC or BIGNUMERIC field must be in this range when:
    ///
    /// * Precision (P) and scale (S) are specified:
    ///   [-10^(P-S) + 10^(-S), 10^(P-S) - 10^(-S)]
    /// * Precision (P) is specified but not scale (and thus scale is
    ///   interpreted to be equal to zero):
    ///   [-10^P + 1, 10^P - 1].
    ///
    /// Acceptable values for precision and scale if both are specified:
    ///
    /// * If type = "NUMERIC":
    ///   1 <= precision - scale <= 29 and 0 <= scale <= 9.
    /// * If type = "BIGNUMERIC":
    ///   1 <= precision - scale <= 38 and 0 <= scale <= 38.
    ///
    /// Acceptable values for precision if only precision is specified but not
    /// scale (and thus scale is interpreted to be equal to zero):
    ///
    /// * If type = "NUMERIC": 1 <= precision <= 29.
    /// * If type = "BIGNUMERIC": 1 <= precision <= 38.
    ///
    /// If scale is specified but not precision, then it is invalid.
    pub precision: i64,

    /// Optional. See documentation for precision.
    pub scale: i64,

    /// Optional. A SQL expression to specify the [default value]
    /// (<https://cloud.google.com/bigquery/docs/default-values>) for this field.
    pub default_value_expression: std::string::String,

    /// Optional. Precision (maximum number of total digits in base 10) for seconds
    /// of TIMESTAMP type.
    ///
    /// Possible values include:
    ///
    /// * 6 (Default, for TIMESTAMP type with microsecond precision)
    /// * 12 (For TIMESTAMP type with picosecond precision)
    pub timestamp_precision: std::option::Option<wkt::Int64Value>,

    /// Optional. The subtype of the RANGE, if the type of this field is RANGE. If
    /// the type is RANGE, this field is required. Possible values for the field
    /// element type of a RANGE include:
    ///
    /// * DATE
    /// * DATETIME
    /// * TIMESTAMP
    pub range_element_type: std::option::Option<
        crate::write::generated::gapic_storage::model::table_field_schema::FieldElementType,
    >,

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

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

    /// Sets the value of [name][crate::write::generated::gapic_storage::model::TableFieldSchema::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::write::generated::gapic_storage::model::TableFieldSchema::type].
    pub fn set_type<
        T: std::convert::Into<crate::write::generated::gapic_storage::model::table_field_schema::Type>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = v.into();
        self
    }

    /// Sets the value of [mode][crate::write::generated::gapic_storage::model::TableFieldSchema::mode].
    pub fn set_mode<
        T: std::convert::Into<crate::write::generated::gapic_storage::model::table_field_schema::Mode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.mode = v.into();
        self
    }

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

    /// Sets the value of [description][crate::write::generated::gapic_storage::model::TableFieldSchema::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 [max_length][crate::write::generated::gapic_storage::model::TableFieldSchema::max_length].
    pub fn set_max_length<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.max_length = v.into();
        self
    }

    /// Sets the value of [precision][crate::write::generated::gapic_storage::model::TableFieldSchema::precision].
    pub fn set_precision<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.precision = v.into();
        self
    }

    /// Sets the value of [scale][crate::write::generated::gapic_storage::model::TableFieldSchema::scale].
    pub fn set_scale<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.scale = v.into();
        self
    }

    /// Sets the value of [default_value_expression][crate::write::generated::gapic_storage::model::TableFieldSchema::default_value_expression].
    pub fn set_default_value_expression<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.default_value_expression = v.into();
        self
    }

    /// Sets the value of [timestamp_precision][crate::write::generated::gapic_storage::model::TableFieldSchema::timestamp_precision].
    pub fn set_timestamp_precision<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Int64Value>,
    {
        self.timestamp_precision = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [timestamp_precision][crate::write::generated::gapic_storage::model::TableFieldSchema::timestamp_precision].
    pub fn set_or_clear_timestamp_precision<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Int64Value>,
    {
        self.timestamp_precision = v.map(|x| x.into());
        self
    }

    /// Sets the value of [range_element_type][crate::write::generated::gapic_storage::model::TableFieldSchema::range_element_type].
    pub fn set_range_element_type<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<
                crate::write::generated::gapic_storage::model::table_field_schema::FieldElementType,
            >,
    {
        self.range_element_type = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [range_element_type][crate::write::generated::gapic_storage::model::TableFieldSchema::range_element_type].
    pub fn set_or_clear_range_element_type<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<
                crate::write::generated::gapic_storage::model::table_field_schema::FieldElementType,
            >,
    {
        self.range_element_type = v.map(|x| x.into());
        self
    }
}

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

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

    /// Represents the type of a field element.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct FieldElementType {
        /// Required. The type of a field element.
        pub r#type: crate::write::generated::gapic_storage::model::table_field_schema::Type,

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

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

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

    impl wkt::message::Message for FieldElementType {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.bigquery.storage.v1.TableFieldSchema.FieldElementType"
        }
    }

    /// Enum for [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 Type {
        /// Illegal value
        Unspecified,
        /// 64K, UTF8
        String,
        /// 64-bit signed
        Int64,
        /// 64-bit IEEE floating point
        Double,
        /// Aggregate type
        Struct,
        /// 64K, Binary
        Bytes,
        /// 2-valued
        Bool,
        /// 64-bit signed usec since UTC epoch
        Timestamp,
        /// Civil date - Year, Month, Day
        Date,
        /// Civil time - Hour, Minute, Second, Microseconds
        Time,
        /// Combination of civil date and civil time
        Datetime,
        /// Geography object
        Geography,
        /// Numeric value
        Numeric,
        /// BigNumeric value
        Bignumeric,
        /// Interval
        Interval,
        /// JSON, String
        Json,
        /// RANGE
        Range,
        /// 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::String => std::option::Option::Some(1),
                Self::Int64 => std::option::Option::Some(2),
                Self::Double => std::option::Option::Some(3),
                Self::Struct => std::option::Option::Some(4),
                Self::Bytes => std::option::Option::Some(5),
                Self::Bool => std::option::Option::Some(6),
                Self::Timestamp => std::option::Option::Some(7),
                Self::Date => std::option::Option::Some(8),
                Self::Time => std::option::Option::Some(9),
                Self::Datetime => std::option::Option::Some(10),
                Self::Geography => std::option::Option::Some(11),
                Self::Numeric => std::option::Option::Some(12),
                Self::Bignumeric => std::option::Option::Some(13),
                Self::Interval => std::option::Option::Some(14),
                Self::Json => std::option::Option::Some(15),
                Self::Range => std::option::Option::Some(16),
                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::String => std::option::Option::Some("STRING"),
                Self::Int64 => std::option::Option::Some("INT64"),
                Self::Double => std::option::Option::Some("DOUBLE"),
                Self::Struct => std::option::Option::Some("STRUCT"),
                Self::Bytes => std::option::Option::Some("BYTES"),
                Self::Bool => std::option::Option::Some("BOOL"),
                Self::Timestamp => std::option::Option::Some("TIMESTAMP"),
                Self::Date => std::option::Option::Some("DATE"),
                Self::Time => std::option::Option::Some("TIME"),
                Self::Datetime => std::option::Option::Some("DATETIME"),
                Self::Geography => std::option::Option::Some("GEOGRAPHY"),
                Self::Numeric => std::option::Option::Some("NUMERIC"),
                Self::Bignumeric => std::option::Option::Some("BIGNUMERIC"),
                Self::Interval => std::option::Option::Some("INTERVAL"),
                Self::Json => std::option::Option::Some("JSON"),
                Self::Range => std::option::Option::Some("RANGE"),
                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::String,
                2 => Self::Int64,
                3 => Self::Double,
                4 => Self::Struct,
                5 => Self::Bytes,
                6 => Self::Bool,
                7 => Self::Timestamp,
                8 => Self::Date,
                9 => Self::Time,
                10 => Self::Datetime,
                11 => Self::Geography,
                12 => Self::Numeric,
                13 => Self::Bignumeric,
                14 => Self::Interval,
                15 => Self::Json,
                16 => Self::Range,
                _ => 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,
                "STRING" => Self::String,
                "INT64" => Self::Int64,
                "DOUBLE" => Self::Double,
                "STRUCT" => Self::Struct,
                "BYTES" => Self::Bytes,
                "BOOL" => Self::Bool,
                "TIMESTAMP" => Self::Timestamp,
                "DATE" => Self::Date,
                "TIME" => Self::Time,
                "DATETIME" => Self::Datetime,
                "GEOGRAPHY" => Self::Geography,
                "NUMERIC" => Self::Numeric,
                "BIGNUMERIC" => Self::Bignumeric,
                "INTERVAL" => Self::Interval,
                "JSON" => Self::Json,
                "RANGE" => Self::Range,
                _ => 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::String => serializer.serialize_i32(1),
                Self::Int64 => serializer.serialize_i32(2),
                Self::Double => serializer.serialize_i32(3),
                Self::Struct => serializer.serialize_i32(4),
                Self::Bytes => serializer.serialize_i32(5),
                Self::Bool => serializer.serialize_i32(6),
                Self::Timestamp => serializer.serialize_i32(7),
                Self::Date => serializer.serialize_i32(8),
                Self::Time => serializer.serialize_i32(9),
                Self::Datetime => serializer.serialize_i32(10),
                Self::Geography => serializer.serialize_i32(11),
                Self::Numeric => serializer.serialize_i32(12),
                Self::Bignumeric => serializer.serialize_i32(13),
                Self::Interval => serializer.serialize_i32(14),
                Self::Json => serializer.serialize_i32(15),
                Self::Range => serializer.serialize_i32(16),
                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.cloud.bigquery.storage.v1.TableFieldSchema.Type",
            ))
        }
    }

    /// Enum for [Mode].
    ///
    /// # 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 Mode {
        /// Illegal value
        Unspecified,
        #[allow(missing_docs)]
        Nullable,
        #[allow(missing_docs)]
        Required,
        #[allow(missing_docs)]
        Repeated,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Mode::value] or
        /// [Mode::name].
        UnknownValue(mode::UnknownValue),
    }

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

    impl Mode {
        /// 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::Nullable => std::option::Option::Some(1),
                Self::Required => std::option::Option::Some(2),
                Self::Repeated => 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("MODE_UNSPECIFIED"),
                Self::Nullable => std::option::Option::Some("NULLABLE"),
                Self::Required => std::option::Option::Some("REQUIRED"),
                Self::Repeated => std::option::Option::Some("REPEATED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

    impl std::fmt::Display for Mode {
        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 Mode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Nullable,
                2 => Self::Required,
                3 => Self::Repeated,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Mode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "MODE_UNSPECIFIED" => Self::Unspecified,
                "NULLABLE" => Self::Nullable,
                "REQUIRED" => Self::Required,
                "REPEATED" => Self::Repeated,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Mode {
        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::Nullable => serializer.serialize_i32(1),
                Self::Required => serializer.serialize_i32(2),
                Self::Repeated => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// Data format for input or output data.
///
/// # 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 DataFormat {
    /// Data format is unspecified.
    Unspecified,
    /// Avro is a standard open source row based file format.
    /// See <https://avro.apache.org/> for more details.
    Avro,
    /// Arrow is a standard open source column-based message format.
    /// See <https://arrow.apache.org/> for more details.
    Arrow,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [DataFormat::value] or
    /// [DataFormat::name].
    UnknownValue(data_format::UnknownValue),
}

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

impl DataFormat {
    /// 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::Avro => std::option::Option::Some(1),
            Self::Arrow => 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("DATA_FORMAT_UNSPECIFIED"),
            Self::Avro => std::option::Option::Some("AVRO"),
            Self::Arrow => std::option::Option::Some("ARROW"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

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

impl std::fmt::Display for DataFormat {
    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 DataFormat {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::Avro,
            2 => Self::Arrow,
            _ => Self::UnknownValue(data_format::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for DataFormat {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "DATA_FORMAT_UNSPECIFIED" => Self::Unspecified,
            "AVRO" => Self::Avro,
            "ARROW" => Self::Arrow,
            _ => Self::UnknownValue(data_format::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for DataFormat {
    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::Avro => serializer.serialize_i32(1),
            Self::Arrow => serializer.serialize_i32(2),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

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

/// WriteStreamView is a view enum that controls what details about a write
/// stream should be returned.
///
/// # 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 WriteStreamView {
    /// The default / unset value.
    Unspecified,
    /// The BASIC projection returns basic metadata about a write stream.  The
    /// basic view does not include schema information.  This is the default view
    /// returned by GetWriteStream.
    Basic,
    /// The FULL projection returns all available write stream metadata, including
    /// the schema.  CreateWriteStream returns the full projection of write stream
    /// metadata.
    Full,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [WriteStreamView::value] or
    /// [WriteStreamView::name].
    UnknownValue(write_stream_view::UnknownValue),
}

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

impl WriteStreamView {
    /// 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::Basic => std::option::Option::Some(1),
            Self::Full => 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("WRITE_STREAM_VIEW_UNSPECIFIED"),
            Self::Basic => std::option::Option::Some("BASIC"),
            Self::Full => std::option::Option::Some("FULL"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

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

impl std::fmt::Display for WriteStreamView {
    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 WriteStreamView {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::Basic,
            2 => Self::Full,
            _ => Self::UnknownValue(write_stream_view::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for WriteStreamView {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "WRITE_STREAM_VIEW_UNSPECIFIED" => Self::Unspecified,
            "BASIC" => Self::Basic,
            "FULL" => Self::Full,
            _ => Self::UnknownValue(write_stream_view::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for WriteStreamView {
    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::Basic => serializer.serialize_i32(1),
            Self::Full => serializer.serialize_i32(2),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

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