google-cloud-rust-raw 0.14.0

// This file is generated by rust-protobuf 2.28.0. Do not edit
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `google/bigtable/v2/bigtable.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_28_0;

#[derive(PartialEq,Clone,Default)]
pub struct ReadRowsRequest {
    // message fields
    pub table_name: ::std::string::String,
    pub app_profile_id: ::std::string::String,
    pub rows: ::protobuf::SingularPtrField<super::data::RowSet>,
    pub filter: ::protobuf::SingularPtrField<super::data::RowFilter>,
    pub rows_limit: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ReadRowsRequest {
    fn default() -> &'a ReadRowsRequest {
        <ReadRowsRequest as ::protobuf::Message>::default_instance()
    }
}

impl ReadRowsRequest {
    pub fn new() -> ReadRowsRequest {
        ::std::default::Default::default()
    }

    // string table_name = 1;


    pub fn get_table_name(&self) -> &str {
        &self.table_name
    }
    pub fn clear_table_name(&mut self) {
        self.table_name.clear();
    }

    // Param is passed by value, moved
    pub fn set_table_name(&mut self, v: ::std::string::String) {
        self.table_name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_table_name(&mut self) -> &mut ::std::string::String {
        &mut self.table_name
    }

    // Take field
    pub fn take_table_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.table_name, ::std::string::String::new())
    }

    // string app_profile_id = 5;


    pub fn get_app_profile_id(&self) -> &str {
        &self.app_profile_id
    }
    pub fn clear_app_profile_id(&mut self) {
        self.app_profile_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_app_profile_id(&mut self, v: ::std::string::String) {
        self.app_profile_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_app_profile_id(&mut self) -> &mut ::std::string::String {
        &mut self.app_profile_id
    }

    // Take field
    pub fn take_app_profile_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.app_profile_id, ::std::string::String::new())
    }

    // .google.bigtable.v2.RowSet rows = 2;


    pub fn get_rows(&self) -> &super::data::RowSet {
        self.rows.as_ref().unwrap_or_else(|| <super::data::RowSet as ::protobuf::Message>::default_instance())
    }
    pub fn clear_rows(&mut self) {
        self.rows.clear();
    }

    pub fn has_rows(&self) -> bool {
        self.rows.is_some()
    }

    // Param is passed by value, moved
    pub fn set_rows(&mut self, v: super::data::RowSet) {
        self.rows = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_rows(&mut self) -> &mut super::data::RowSet {
        if self.rows.is_none() {
            self.rows.set_default();
        }
        self.rows.as_mut().unwrap()
    }

    // Take field
    pub fn take_rows(&mut self) -> super::data::RowSet {
        self.rows.take().unwrap_or_else(|| super::data::RowSet::new())
    }

    // .google.bigtable.v2.RowFilter filter = 3;


    pub fn get_filter(&self) -> &super::data::RowFilter {
        self.filter.as_ref().unwrap_or_else(|| <super::data::RowFilter as ::protobuf::Message>::default_instance())
    }
    pub fn clear_filter(&mut self) {
        self.filter.clear();
    }

    pub fn has_filter(&self) -> bool {
        self.filter.is_some()
    }

    // Param is passed by value, moved
    pub fn set_filter(&mut self, v: super::data::RowFilter) {
        self.filter = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_filter(&mut self) -> &mut super::data::RowFilter {
        if self.filter.is_none() {
            self.filter.set_default();
        }
        self.filter.as_mut().unwrap()
    }

    // Take field
    pub fn take_filter(&mut self) -> super::data::RowFilter {
        self.filter.take().unwrap_or_else(|| super::data::RowFilter::new())
    }

    // int64 rows_limit = 4;


    pub fn get_rows_limit(&self) -> i64 {
        self.rows_limit
    }
    pub fn clear_rows_limit(&mut self) {
        self.rows_limit = 0;
    }

    // Param is passed by value, moved
    pub fn set_rows_limit(&mut self, v: i64) {
        self.rows_limit = v;
    }
}

impl ::protobuf::Message for ReadRowsRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.rows {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.filter {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.app_profile_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.rows)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.filter)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.rows_limit = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.table_name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.table_name);
        }
        if !self.app_profile_id.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.app_profile_id);
        }
        if let Some(ref v) = self.rows.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.filter.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.rows_limit != 0 {
            my_size += ::protobuf::rt::value_size(4, self.rows_limit, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.table_name.is_empty() {
            os.write_string(1, &self.table_name)?;
        }
        if !self.app_profile_id.is_empty() {
            os.write_string(5, &self.app_profile_id)?;
        }
        if let Some(ref v) = self.rows.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.filter.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.rows_limit != 0 {
            os.write_int64(4, self.rows_limit)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ReadRowsRequest {
        ReadRowsRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "table_name",
                |m: &ReadRowsRequest| { &m.table_name },
                |m: &mut ReadRowsRequest| { &mut m.table_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "app_profile_id",
                |m: &ReadRowsRequest| { &m.app_profile_id },
                |m: &mut ReadRowsRequest| { &mut m.app_profile_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::data::RowSet>>(
                "rows",
                |m: &ReadRowsRequest| { &m.rows },
                |m: &mut ReadRowsRequest| { &mut m.rows },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::data::RowFilter>>(
                "filter",
                |m: &ReadRowsRequest| { &m.filter },
                |m: &mut ReadRowsRequest| { &mut m.filter },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "rows_limit",
                |m: &ReadRowsRequest| { &m.rows_limit },
                |m: &mut ReadRowsRequest| { &mut m.rows_limit },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ReadRowsRequest>(
                "ReadRowsRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ReadRowsRequest {
        static instance: ::protobuf::rt::LazyV2<ReadRowsRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ReadRowsRequest::new)
    }
}

impl ::protobuf::Clear for ReadRowsRequest {
    fn clear(&mut self) {
        self.table_name.clear();
        self.app_profile_id.clear();
        self.rows.clear();
        self.filter.clear();
        self.rows_limit = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ReadRowsRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ReadRowsRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ReadRowsResponse {
    // message fields
    pub chunks: ::protobuf::RepeatedField<ReadRowsResponse_CellChunk>,
    pub last_scanned_row_key: ::std::vec::Vec<u8>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ReadRowsResponse {
    fn default() -> &'a ReadRowsResponse {
        <ReadRowsResponse as ::protobuf::Message>::default_instance()
    }
}

impl ReadRowsResponse {
    pub fn new() -> ReadRowsResponse {
        ::std::default::Default::default()
    }

    // repeated .google.bigtable.v2.ReadRowsResponse.CellChunk chunks = 1;


    pub fn get_chunks(&self) -> &[ReadRowsResponse_CellChunk] {
        &self.chunks
    }
    pub fn clear_chunks(&mut self) {
        self.chunks.clear();
    }

    // Param is passed by value, moved
    pub fn set_chunks(&mut self, v: ::protobuf::RepeatedField<ReadRowsResponse_CellChunk>) {
        self.chunks = v;
    }

    // Mutable pointer to the field.
    pub fn mut_chunks(&mut self) -> &mut ::protobuf::RepeatedField<ReadRowsResponse_CellChunk> {
        &mut self.chunks
    }

    // Take field
    pub fn take_chunks(&mut self) -> ::protobuf::RepeatedField<ReadRowsResponse_CellChunk> {
        ::std::mem::replace(&mut self.chunks, ::protobuf::RepeatedField::new())
    }

    // bytes last_scanned_row_key = 2;


    pub fn get_last_scanned_row_key(&self) -> &[u8] {
        &self.last_scanned_row_key
    }
    pub fn clear_last_scanned_row_key(&mut self) {
        self.last_scanned_row_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_last_scanned_row_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.last_scanned_row_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_last_scanned_row_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.last_scanned_row_key
    }

    // Take field
    pub fn take_last_scanned_row_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.last_scanned_row_key, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for ReadRowsResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.chunks {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.chunks)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.last_scanned_row_key)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.chunks {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if !self.last_scanned_row_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.last_scanned_row_key);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.chunks {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if !self.last_scanned_row_key.is_empty() {
            os.write_bytes(2, &self.last_scanned_row_key)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ReadRowsResponse {
        ReadRowsResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ReadRowsResponse_CellChunk>>(
                "chunks",
                |m: &ReadRowsResponse| { &m.chunks },
                |m: &mut ReadRowsResponse| { &mut m.chunks },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "last_scanned_row_key",
                |m: &ReadRowsResponse| { &m.last_scanned_row_key },
                |m: &mut ReadRowsResponse| { &mut m.last_scanned_row_key },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ReadRowsResponse>(
                "ReadRowsResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ReadRowsResponse {
        static instance: ::protobuf::rt::LazyV2<ReadRowsResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ReadRowsResponse::new)
    }
}

impl ::protobuf::Clear for ReadRowsResponse {
    fn clear(&mut self) {
        self.chunks.clear();
        self.last_scanned_row_key.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ReadRowsResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ReadRowsResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ReadRowsResponse_CellChunk {
    // message fields
    pub row_key: ::std::vec::Vec<u8>,
    pub family_name: ::protobuf::SingularPtrField<::protobuf::well_known_types::StringValue>,
    pub qualifier: ::protobuf::SingularPtrField<::protobuf::well_known_types::BytesValue>,
    pub timestamp_micros: i64,
    pub labels: ::protobuf::RepeatedField<::std::string::String>,
    pub value: ::std::vec::Vec<u8>,
    pub value_size: i32,
    // message oneof groups
    pub row_status: ::std::option::Option<ReadRowsResponse_CellChunk_oneof_row_status>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ReadRowsResponse_CellChunk {
    fn default() -> &'a ReadRowsResponse_CellChunk {
        <ReadRowsResponse_CellChunk as ::protobuf::Message>::default_instance()
    }
}

#[derive(Clone,PartialEq,Debug)]
pub enum ReadRowsResponse_CellChunk_oneof_row_status {
    reset_row(bool),
    commit_row(bool),
}

impl ReadRowsResponse_CellChunk {
    pub fn new() -> ReadRowsResponse_CellChunk {
        ::std::default::Default::default()
    }

    // bytes row_key = 1;


    pub fn get_row_key(&self) -> &[u8] {
        &self.row_key
    }
    pub fn clear_row_key(&mut self) {
        self.row_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_row_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.row_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.row_key
    }

    // Take field
    pub fn take_row_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new())
    }

    // .google.protobuf.StringValue family_name = 2;


    pub fn get_family_name(&self) -> &::protobuf::well_known_types::StringValue {
        self.family_name.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::StringValue as ::protobuf::Message>::default_instance())
    }
    pub fn clear_family_name(&mut self) {
        self.family_name.clear();
    }

    pub fn has_family_name(&self) -> bool {
        self.family_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_family_name(&mut self, v: ::protobuf::well_known_types::StringValue) {
        self.family_name = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_family_name(&mut self) -> &mut ::protobuf::well_known_types::StringValue {
        if self.family_name.is_none() {
            self.family_name.set_default();
        }
        self.family_name.as_mut().unwrap()
    }

    // Take field
    pub fn take_family_name(&mut self) -> ::protobuf::well_known_types::StringValue {
        self.family_name.take().unwrap_or_else(|| ::protobuf::well_known_types::StringValue::new())
    }

    // .google.protobuf.BytesValue qualifier = 3;


    pub fn get_qualifier(&self) -> &::protobuf::well_known_types::BytesValue {
        self.qualifier.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::BytesValue as ::protobuf::Message>::default_instance())
    }
    pub fn clear_qualifier(&mut self) {
        self.qualifier.clear();
    }

    pub fn has_qualifier(&self) -> bool {
        self.qualifier.is_some()
    }

    // Param is passed by value, moved
    pub fn set_qualifier(&mut self, v: ::protobuf::well_known_types::BytesValue) {
        self.qualifier = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_qualifier(&mut self) -> &mut ::protobuf::well_known_types::BytesValue {
        if self.qualifier.is_none() {
            self.qualifier.set_default();
        }
        self.qualifier.as_mut().unwrap()
    }

    // Take field
    pub fn take_qualifier(&mut self) -> ::protobuf::well_known_types::BytesValue {
        self.qualifier.take().unwrap_or_else(|| ::protobuf::well_known_types::BytesValue::new())
    }

    // int64 timestamp_micros = 4;


    pub fn get_timestamp_micros(&self) -> i64 {
        self.timestamp_micros
    }
    pub fn clear_timestamp_micros(&mut self) {
        self.timestamp_micros = 0;
    }

    // Param is passed by value, moved
    pub fn set_timestamp_micros(&mut self, v: i64) {
        self.timestamp_micros = v;
    }

    // repeated string labels = 5;


    pub fn get_labels(&self) -> &[::std::string::String] {
        &self.labels
    }
    pub fn clear_labels(&mut self) {
        self.labels.clear();
    }

    // Param is passed by value, moved
    pub fn set_labels(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.labels = v;
    }

    // Mutable pointer to the field.
    pub fn mut_labels(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.labels
    }

    // Take field
    pub fn take_labels(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.labels, ::protobuf::RepeatedField::new())
    }

    // bytes value = 6;


    pub fn get_value(&self) -> &[u8] {
        &self.value
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: ::std::vec::Vec<u8>) {
        self.value = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_value(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.value
    }

    // Take field
    pub fn take_value(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.value, ::std::vec::Vec::new())
    }

    // int32 value_size = 7;


    pub fn get_value_size(&self) -> i32 {
        self.value_size
    }
    pub fn clear_value_size(&mut self) {
        self.value_size = 0;
    }

    // Param is passed by value, moved
    pub fn set_value_size(&mut self, v: i32) {
        self.value_size = v;
    }

    // bool reset_row = 8;


    pub fn get_reset_row(&self) -> bool {
        match self.row_status {
            ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::reset_row(v)) => v,
            _ => false,
        }
    }
    pub fn clear_reset_row(&mut self) {
        self.row_status = ::std::option::Option::None;
    }

    pub fn has_reset_row(&self) -> bool {
        match self.row_status {
            ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::reset_row(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_reset_row(&mut self, v: bool) {
        self.row_status = ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::reset_row(v))
    }

    // bool commit_row = 9;


    pub fn get_commit_row(&self) -> bool {
        match self.row_status {
            ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::commit_row(v)) => v,
            _ => false,
        }
    }
    pub fn clear_commit_row(&mut self) {
        self.row_status = ::std::option::Option::None;
    }

    pub fn has_commit_row(&self) -> bool {
        match self.row_status {
            ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::commit_row(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_commit_row(&mut self, v: bool) {
        self.row_status = ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::commit_row(v))
    }
}

impl ::protobuf::Message for ReadRowsResponse_CellChunk {
    fn is_initialized(&self) -> bool {
        for v in &self.family_name {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.qualifier {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.family_name)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.qualifier)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.timestamp_micros = tmp;
                },
                5 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.labels)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.value_size = tmp;
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.row_status = ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::reset_row(is.read_bool()?));
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.row_status = ::std::option::Option::Some(ReadRowsResponse_CellChunk_oneof_row_status::commit_row(is.read_bool()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.row_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.row_key);
        }
        if let Some(ref v) = self.family_name.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.qualifier.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.timestamp_micros != 0 {
            my_size += ::protobuf::rt::value_size(4, self.timestamp_micros, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.labels {
            my_size += ::protobuf::rt::string_size(5, &value);
        };
        if !self.value.is_empty() {
            my_size += ::protobuf::rt::bytes_size(6, &self.value);
        }
        if self.value_size != 0 {
            my_size += ::protobuf::rt::value_size(7, self.value_size, ::protobuf::wire_format::WireTypeVarint);
        }
        if let ::std::option::Option::Some(ref v) = self.row_status {
            match v {
                &ReadRowsResponse_CellChunk_oneof_row_status::reset_row(v) => {
                    my_size += 2;
                },
                &ReadRowsResponse_CellChunk_oneof_row_status::commit_row(v) => {
                    my_size += 2;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.row_key.is_empty() {
            os.write_bytes(1, &self.row_key)?;
        }
        if let Some(ref v) = self.family_name.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.qualifier.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.timestamp_micros != 0 {
            os.write_int64(4, self.timestamp_micros)?;
        }
        for v in &self.labels {
            os.write_string(5, &v)?;
        };
        if !self.value.is_empty() {
            os.write_bytes(6, &self.value)?;
        }
        if self.value_size != 0 {
            os.write_int32(7, self.value_size)?;
        }
        if let ::std::option::Option::Some(ref v) = self.row_status {
            match v {
                &ReadRowsResponse_CellChunk_oneof_row_status::reset_row(v) => {
                    os.write_bool(8, v)?;
                },
                &ReadRowsResponse_CellChunk_oneof_row_status::commit_row(v) => {
                    os.write_bool(9, v)?;
                },
            };
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ReadRowsResponse_CellChunk {
        ReadRowsResponse_CellChunk::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "row_key",
                |m: &ReadRowsResponse_CellChunk| { &m.row_key },
                |m: &mut ReadRowsResponse_CellChunk| { &mut m.row_key },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::StringValue>>(
                "family_name",
                |m: &ReadRowsResponse_CellChunk| { &m.family_name },
                |m: &mut ReadRowsResponse_CellChunk| { &mut m.family_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::BytesValue>>(
                "qualifier",
                |m: &ReadRowsResponse_CellChunk| { &m.qualifier },
                |m: &mut ReadRowsResponse_CellChunk| { &mut m.qualifier },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "timestamp_micros",
                |m: &ReadRowsResponse_CellChunk| { &m.timestamp_micros },
                |m: &mut ReadRowsResponse_CellChunk| { &mut m.timestamp_micros },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "labels",
                |m: &ReadRowsResponse_CellChunk| { &m.labels },
                |m: &mut ReadRowsResponse_CellChunk| { &mut m.labels },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "value",
                |m: &ReadRowsResponse_CellChunk| { &m.value },
                |m: &mut ReadRowsResponse_CellChunk| { &mut m.value },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "value_size",
                |m: &ReadRowsResponse_CellChunk| { &m.value_size },
                |m: &mut ReadRowsResponse_CellChunk| { &mut m.value_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>(
                "reset_row",
                ReadRowsResponse_CellChunk::has_reset_row,
                ReadRowsResponse_CellChunk::get_reset_row,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>(
                "commit_row",
                ReadRowsResponse_CellChunk::has_commit_row,
                ReadRowsResponse_CellChunk::get_commit_row,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ReadRowsResponse_CellChunk>(
                "ReadRowsResponse.CellChunk",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ReadRowsResponse_CellChunk {
        static instance: ::protobuf::rt::LazyV2<ReadRowsResponse_CellChunk> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ReadRowsResponse_CellChunk::new)
    }
}

impl ::protobuf::Clear for ReadRowsResponse_CellChunk {
    fn clear(&mut self) {
        self.row_key.clear();
        self.family_name.clear();
        self.qualifier.clear();
        self.timestamp_micros = 0;
        self.labels.clear();
        self.value.clear();
        self.value_size = 0;
        self.row_status = ::std::option::Option::None;
        self.row_status = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ReadRowsResponse_CellChunk {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ReadRowsResponse_CellChunk {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct SampleRowKeysRequest {
    // message fields
    pub table_name: ::std::string::String,
    pub app_profile_id: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a SampleRowKeysRequest {
    fn default() -> &'a SampleRowKeysRequest {
        <SampleRowKeysRequest as ::protobuf::Message>::default_instance()
    }
}

impl SampleRowKeysRequest {
    pub fn new() -> SampleRowKeysRequest {
        ::std::default::Default::default()
    }

    // string table_name = 1;


    pub fn get_table_name(&self) -> &str {
        &self.table_name
    }
    pub fn clear_table_name(&mut self) {
        self.table_name.clear();
    }

    // Param is passed by value, moved
    pub fn set_table_name(&mut self, v: ::std::string::String) {
        self.table_name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_table_name(&mut self) -> &mut ::std::string::String {
        &mut self.table_name
    }

    // Take field
    pub fn take_table_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.table_name, ::std::string::String::new())
    }

    // string app_profile_id = 2;


    pub fn get_app_profile_id(&self) -> &str {
        &self.app_profile_id
    }
    pub fn clear_app_profile_id(&mut self) {
        self.app_profile_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_app_profile_id(&mut self, v: ::std::string::String) {
        self.app_profile_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_app_profile_id(&mut self) -> &mut ::std::string::String {
        &mut self.app_profile_id
    }

    // Take field
    pub fn take_app_profile_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.app_profile_id, ::std::string::String::new())
    }
}

impl ::protobuf::Message for SampleRowKeysRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.app_profile_id)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.table_name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.table_name);
        }
        if !self.app_profile_id.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.app_profile_id);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.table_name.is_empty() {
            os.write_string(1, &self.table_name)?;
        }
        if !self.app_profile_id.is_empty() {
            os.write_string(2, &self.app_profile_id)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> SampleRowKeysRequest {
        SampleRowKeysRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "table_name",
                |m: &SampleRowKeysRequest| { &m.table_name },
                |m: &mut SampleRowKeysRequest| { &mut m.table_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "app_profile_id",
                |m: &SampleRowKeysRequest| { &m.app_profile_id },
                |m: &mut SampleRowKeysRequest| { &mut m.app_profile_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SampleRowKeysRequest>(
                "SampleRowKeysRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static SampleRowKeysRequest {
        static instance: ::protobuf::rt::LazyV2<SampleRowKeysRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(SampleRowKeysRequest::new)
    }
}

impl ::protobuf::Clear for SampleRowKeysRequest {
    fn clear(&mut self) {
        self.table_name.clear();
        self.app_profile_id.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for SampleRowKeysRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for SampleRowKeysRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct SampleRowKeysResponse {
    // message fields
    pub row_key: ::std::vec::Vec<u8>,
    pub offset_bytes: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a SampleRowKeysResponse {
    fn default() -> &'a SampleRowKeysResponse {
        <SampleRowKeysResponse as ::protobuf::Message>::default_instance()
    }
}

impl SampleRowKeysResponse {
    pub fn new() -> SampleRowKeysResponse {
        ::std::default::Default::default()
    }

    // bytes row_key = 1;


    pub fn get_row_key(&self) -> &[u8] {
        &self.row_key
    }
    pub fn clear_row_key(&mut self) {
        self.row_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_row_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.row_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.row_key
    }

    // Take field
    pub fn take_row_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new())
    }

    // int64 offset_bytes = 2;


    pub fn get_offset_bytes(&self) -> i64 {
        self.offset_bytes
    }
    pub fn clear_offset_bytes(&mut self) {
        self.offset_bytes = 0;
    }

    // Param is passed by value, moved
    pub fn set_offset_bytes(&mut self, v: i64) {
        self.offset_bytes = v;
    }
}

impl ::protobuf::Message for SampleRowKeysResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.offset_bytes = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.row_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.row_key);
        }
        if self.offset_bytes != 0 {
            my_size += ::protobuf::rt::value_size(2, self.offset_bytes, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.row_key.is_empty() {
            os.write_bytes(1, &self.row_key)?;
        }
        if self.offset_bytes != 0 {
            os.write_int64(2, self.offset_bytes)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> SampleRowKeysResponse {
        SampleRowKeysResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "row_key",
                |m: &SampleRowKeysResponse| { &m.row_key },
                |m: &mut SampleRowKeysResponse| { &mut m.row_key },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "offset_bytes",
                |m: &SampleRowKeysResponse| { &m.offset_bytes },
                |m: &mut SampleRowKeysResponse| { &mut m.offset_bytes },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SampleRowKeysResponse>(
                "SampleRowKeysResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static SampleRowKeysResponse {
        static instance: ::protobuf::rt::LazyV2<SampleRowKeysResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(SampleRowKeysResponse::new)
    }
}

impl ::protobuf::Clear for SampleRowKeysResponse {
    fn clear(&mut self) {
        self.row_key.clear();
        self.offset_bytes = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for SampleRowKeysResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for SampleRowKeysResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct MutateRowRequest {
    // message fields
    pub table_name: ::std::string::String,
    pub app_profile_id: ::std::string::String,
    pub row_key: ::std::vec::Vec<u8>,
    pub mutations: ::protobuf::RepeatedField<super::data::Mutation>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a MutateRowRequest {
    fn default() -> &'a MutateRowRequest {
        <MutateRowRequest as ::protobuf::Message>::default_instance()
    }
}

impl MutateRowRequest {
    pub fn new() -> MutateRowRequest {
        ::std::default::Default::default()
    }

    // string table_name = 1;


    pub fn get_table_name(&self) -> &str {
        &self.table_name
    }
    pub fn clear_table_name(&mut self) {
        self.table_name.clear();
    }

    // Param is passed by value, moved
    pub fn set_table_name(&mut self, v: ::std::string::String) {
        self.table_name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_table_name(&mut self) -> &mut ::std::string::String {
        &mut self.table_name
    }

    // Take field
    pub fn take_table_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.table_name, ::std::string::String::new())
    }

    // string app_profile_id = 4;


    pub fn get_app_profile_id(&self) -> &str {
        &self.app_profile_id
    }
    pub fn clear_app_profile_id(&mut self) {
        self.app_profile_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_app_profile_id(&mut self, v: ::std::string::String) {
        self.app_profile_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_app_profile_id(&mut self) -> &mut ::std::string::String {
        &mut self.app_profile_id
    }

    // Take field
    pub fn take_app_profile_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.app_profile_id, ::std::string::String::new())
    }

    // bytes row_key = 2;


    pub fn get_row_key(&self) -> &[u8] {
        &self.row_key
    }
    pub fn clear_row_key(&mut self) {
        self.row_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_row_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.row_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.row_key
    }

    // Take field
    pub fn take_row_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new())
    }

    // repeated .google.bigtable.v2.Mutation mutations = 3;


    pub fn get_mutations(&self) -> &[super::data::Mutation] {
        &self.mutations
    }
    pub fn clear_mutations(&mut self) {
        self.mutations.clear();
    }

    // Param is passed by value, moved
    pub fn set_mutations(&mut self, v: ::protobuf::RepeatedField<super::data::Mutation>) {
        self.mutations = v;
    }

    // Mutable pointer to the field.
    pub fn mut_mutations(&mut self) -> &mut ::protobuf::RepeatedField<super::data::Mutation> {
        &mut self.mutations
    }

    // Take field
    pub fn take_mutations(&mut self) -> ::protobuf::RepeatedField<super::data::Mutation> {
        ::std::mem::replace(&mut self.mutations, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for MutateRowRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.mutations {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.app_profile_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mutations)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.table_name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.table_name);
        }
        if !self.app_profile_id.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.app_profile_id);
        }
        if !self.row_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.row_key);
        }
        for value in &self.mutations {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.table_name.is_empty() {
            os.write_string(1, &self.table_name)?;
        }
        if !self.app_profile_id.is_empty() {
            os.write_string(4, &self.app_profile_id)?;
        }
        if !self.row_key.is_empty() {
            os.write_bytes(2, &self.row_key)?;
        }
        for v in &self.mutations {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> MutateRowRequest {
        MutateRowRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "table_name",
                |m: &MutateRowRequest| { &m.table_name },
                |m: &mut MutateRowRequest| { &mut m.table_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "app_profile_id",
                |m: &MutateRowRequest| { &m.app_profile_id },
                |m: &mut MutateRowRequest| { &mut m.app_profile_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "row_key",
                |m: &MutateRowRequest| { &m.row_key },
                |m: &mut MutateRowRequest| { &mut m.row_key },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::data::Mutation>>(
                "mutations",
                |m: &MutateRowRequest| { &m.mutations },
                |m: &mut MutateRowRequest| { &mut m.mutations },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MutateRowRequest>(
                "MutateRowRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static MutateRowRequest {
        static instance: ::protobuf::rt::LazyV2<MutateRowRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(MutateRowRequest::new)
    }
}

impl ::protobuf::Clear for MutateRowRequest {
    fn clear(&mut self) {
        self.table_name.clear();
        self.app_profile_id.clear();
        self.row_key.clear();
        self.mutations.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for MutateRowRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for MutateRowRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct MutateRowResponse {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a MutateRowResponse {
    fn default() -> &'a MutateRowResponse {
        <MutateRowResponse as ::protobuf::Message>::default_instance()
    }
}

impl MutateRowResponse {
    pub fn new() -> MutateRowResponse {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for MutateRowResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> MutateRowResponse {
        MutateRowResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let fields = ::std::vec::Vec::new();
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MutateRowResponse>(
                "MutateRowResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static MutateRowResponse {
        static instance: ::protobuf::rt::LazyV2<MutateRowResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(MutateRowResponse::new)
    }
}

impl ::protobuf::Clear for MutateRowResponse {
    fn clear(&mut self) {
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for MutateRowResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for MutateRowResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct MutateRowsRequest {
    // message fields
    pub table_name: ::std::string::String,
    pub app_profile_id: ::std::string::String,
    pub entries: ::protobuf::RepeatedField<MutateRowsRequest_Entry>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a MutateRowsRequest {
    fn default() -> &'a MutateRowsRequest {
        <MutateRowsRequest as ::protobuf::Message>::default_instance()
    }
}

impl MutateRowsRequest {
    pub fn new() -> MutateRowsRequest {
        ::std::default::Default::default()
    }

    // string table_name = 1;


    pub fn get_table_name(&self) -> &str {
        &self.table_name
    }
    pub fn clear_table_name(&mut self) {
        self.table_name.clear();
    }

    // Param is passed by value, moved
    pub fn set_table_name(&mut self, v: ::std::string::String) {
        self.table_name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_table_name(&mut self) -> &mut ::std::string::String {
        &mut self.table_name
    }

    // Take field
    pub fn take_table_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.table_name, ::std::string::String::new())
    }

    // string app_profile_id = 3;


    pub fn get_app_profile_id(&self) -> &str {
        &self.app_profile_id
    }
    pub fn clear_app_profile_id(&mut self) {
        self.app_profile_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_app_profile_id(&mut self, v: ::std::string::String) {
        self.app_profile_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_app_profile_id(&mut self) -> &mut ::std::string::String {
        &mut self.app_profile_id
    }

    // Take field
    pub fn take_app_profile_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.app_profile_id, ::std::string::String::new())
    }

    // repeated .google.bigtable.v2.MutateRowsRequest.Entry entries = 2;


    pub fn get_entries(&self) -> &[MutateRowsRequest_Entry] {
        &self.entries
    }
    pub fn clear_entries(&mut self) {
        self.entries.clear();
    }

    // Param is passed by value, moved
    pub fn set_entries(&mut self, v: ::protobuf::RepeatedField<MutateRowsRequest_Entry>) {
        self.entries = v;
    }

    // Mutable pointer to the field.
    pub fn mut_entries(&mut self) -> &mut ::protobuf::RepeatedField<MutateRowsRequest_Entry> {
        &mut self.entries
    }

    // Take field
    pub fn take_entries(&mut self) -> ::protobuf::RepeatedField<MutateRowsRequest_Entry> {
        ::std::mem::replace(&mut self.entries, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for MutateRowsRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.entries {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.app_profile_id)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.entries)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.table_name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.table_name);
        }
        if !self.app_profile_id.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.app_profile_id);
        }
        for value in &self.entries {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.table_name.is_empty() {
            os.write_string(1, &self.table_name)?;
        }
        if !self.app_profile_id.is_empty() {
            os.write_string(3, &self.app_profile_id)?;
        }
        for v in &self.entries {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> MutateRowsRequest {
        MutateRowsRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "table_name",
                |m: &MutateRowsRequest| { &m.table_name },
                |m: &mut MutateRowsRequest| { &mut m.table_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "app_profile_id",
                |m: &MutateRowsRequest| { &m.app_profile_id },
                |m: &mut MutateRowsRequest| { &mut m.app_profile_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MutateRowsRequest_Entry>>(
                "entries",
                |m: &MutateRowsRequest| { &m.entries },
                |m: &mut MutateRowsRequest| { &mut m.entries },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MutateRowsRequest>(
                "MutateRowsRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static MutateRowsRequest {
        static instance: ::protobuf::rt::LazyV2<MutateRowsRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(MutateRowsRequest::new)
    }
}

impl ::protobuf::Clear for MutateRowsRequest {
    fn clear(&mut self) {
        self.table_name.clear();
        self.app_profile_id.clear();
        self.entries.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for MutateRowsRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for MutateRowsRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct MutateRowsRequest_Entry {
    // message fields
    pub row_key: ::std::vec::Vec<u8>,
    pub mutations: ::protobuf::RepeatedField<super::data::Mutation>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a MutateRowsRequest_Entry {
    fn default() -> &'a MutateRowsRequest_Entry {
        <MutateRowsRequest_Entry as ::protobuf::Message>::default_instance()
    }
}

impl MutateRowsRequest_Entry {
    pub fn new() -> MutateRowsRequest_Entry {
        ::std::default::Default::default()
    }

    // bytes row_key = 1;


    pub fn get_row_key(&self) -> &[u8] {
        &self.row_key
    }
    pub fn clear_row_key(&mut self) {
        self.row_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_row_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.row_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.row_key
    }

    // Take field
    pub fn take_row_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new())
    }

    // repeated .google.bigtable.v2.Mutation mutations = 2;


    pub fn get_mutations(&self) -> &[super::data::Mutation] {
        &self.mutations
    }
    pub fn clear_mutations(&mut self) {
        self.mutations.clear();
    }

    // Param is passed by value, moved
    pub fn set_mutations(&mut self, v: ::protobuf::RepeatedField<super::data::Mutation>) {
        self.mutations = v;
    }

    // Mutable pointer to the field.
    pub fn mut_mutations(&mut self) -> &mut ::protobuf::RepeatedField<super::data::Mutation> {
        &mut self.mutations
    }

    // Take field
    pub fn take_mutations(&mut self) -> ::protobuf::RepeatedField<super::data::Mutation> {
        ::std::mem::replace(&mut self.mutations, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for MutateRowsRequest_Entry {
    fn is_initialized(&self) -> bool {
        for v in &self.mutations {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mutations)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.row_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.row_key);
        }
        for value in &self.mutations {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.row_key.is_empty() {
            os.write_bytes(1, &self.row_key)?;
        }
        for v in &self.mutations {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> MutateRowsRequest_Entry {
        MutateRowsRequest_Entry::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "row_key",
                |m: &MutateRowsRequest_Entry| { &m.row_key },
                |m: &mut MutateRowsRequest_Entry| { &mut m.row_key },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::data::Mutation>>(
                "mutations",
                |m: &MutateRowsRequest_Entry| { &m.mutations },
                |m: &mut MutateRowsRequest_Entry| { &mut m.mutations },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MutateRowsRequest_Entry>(
                "MutateRowsRequest.Entry",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static MutateRowsRequest_Entry {
        static instance: ::protobuf::rt::LazyV2<MutateRowsRequest_Entry> = ::protobuf::rt::LazyV2::INIT;
        instance.get(MutateRowsRequest_Entry::new)
    }
}

impl ::protobuf::Clear for MutateRowsRequest_Entry {
    fn clear(&mut self) {
        self.row_key.clear();
        self.mutations.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for MutateRowsRequest_Entry {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for MutateRowsRequest_Entry {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct MutateRowsResponse {
    // message fields
    pub entries: ::protobuf::RepeatedField<MutateRowsResponse_Entry>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a MutateRowsResponse {
    fn default() -> &'a MutateRowsResponse {
        <MutateRowsResponse as ::protobuf::Message>::default_instance()
    }
}

impl MutateRowsResponse {
    pub fn new() -> MutateRowsResponse {
        ::std::default::Default::default()
    }

    // repeated .google.bigtable.v2.MutateRowsResponse.Entry entries = 1;


    pub fn get_entries(&self) -> &[MutateRowsResponse_Entry] {
        &self.entries
    }
    pub fn clear_entries(&mut self) {
        self.entries.clear();
    }

    // Param is passed by value, moved
    pub fn set_entries(&mut self, v: ::protobuf::RepeatedField<MutateRowsResponse_Entry>) {
        self.entries = v;
    }

    // Mutable pointer to the field.
    pub fn mut_entries(&mut self) -> &mut ::protobuf::RepeatedField<MutateRowsResponse_Entry> {
        &mut self.entries
    }

    // Take field
    pub fn take_entries(&mut self) -> ::protobuf::RepeatedField<MutateRowsResponse_Entry> {
        ::std::mem::replace(&mut self.entries, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for MutateRowsResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.entries {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.entries)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.entries {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.entries {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> MutateRowsResponse {
        MutateRowsResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MutateRowsResponse_Entry>>(
                "entries",
                |m: &MutateRowsResponse| { &m.entries },
                |m: &mut MutateRowsResponse| { &mut m.entries },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MutateRowsResponse>(
                "MutateRowsResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static MutateRowsResponse {
        static instance: ::protobuf::rt::LazyV2<MutateRowsResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(MutateRowsResponse::new)
    }
}

impl ::protobuf::Clear for MutateRowsResponse {
    fn clear(&mut self) {
        self.entries.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for MutateRowsResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for MutateRowsResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct MutateRowsResponse_Entry {
    // message fields
    pub index: i64,
    pub status: ::protobuf::SingularPtrField<super::status::Status>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a MutateRowsResponse_Entry {
    fn default() -> &'a MutateRowsResponse_Entry {
        <MutateRowsResponse_Entry as ::protobuf::Message>::default_instance()
    }
}

impl MutateRowsResponse_Entry {
    pub fn new() -> MutateRowsResponse_Entry {
        ::std::default::Default::default()
    }

    // int64 index = 1;


    pub fn get_index(&self) -> i64 {
        self.index
    }
    pub fn clear_index(&mut self) {
        self.index = 0;
    }

    // Param is passed by value, moved
    pub fn set_index(&mut self, v: i64) {
        self.index = v;
    }

    // .google.rpc.Status status = 2;


    pub fn get_status(&self) -> &super::status::Status {
        self.status.as_ref().unwrap_or_else(|| <super::status::Status as ::protobuf::Message>::default_instance())
    }
    pub fn clear_status(&mut self) {
        self.status.clear();
    }

    pub fn has_status(&self) -> bool {
        self.status.is_some()
    }

    // Param is passed by value, moved
    pub fn set_status(&mut self, v: super::status::Status) {
        self.status = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_status(&mut self) -> &mut super::status::Status {
        if self.status.is_none() {
            self.status.set_default();
        }
        self.status.as_mut().unwrap()
    }

    // Take field
    pub fn take_status(&mut self) -> super::status::Status {
        self.status.take().unwrap_or_else(|| super::status::Status::new())
    }
}

impl ::protobuf::Message for MutateRowsResponse_Entry {
    fn is_initialized(&self) -> bool {
        for v in &self.status {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.index = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.status)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.index != 0 {
            my_size += ::protobuf::rt::value_size(1, self.index, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.status.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.index != 0 {
            os.write_int64(1, self.index)?;
        }
        if let Some(ref v) = self.status.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> MutateRowsResponse_Entry {
        MutateRowsResponse_Entry::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "index",
                |m: &MutateRowsResponse_Entry| { &m.index },
                |m: &mut MutateRowsResponse_Entry| { &mut m.index },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::status::Status>>(
                "status",
                |m: &MutateRowsResponse_Entry| { &m.status },
                |m: &mut MutateRowsResponse_Entry| { &mut m.status },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MutateRowsResponse_Entry>(
                "MutateRowsResponse.Entry",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static MutateRowsResponse_Entry {
        static instance: ::protobuf::rt::LazyV2<MutateRowsResponse_Entry> = ::protobuf::rt::LazyV2::INIT;
        instance.get(MutateRowsResponse_Entry::new)
    }
}

impl ::protobuf::Clear for MutateRowsResponse_Entry {
    fn clear(&mut self) {
        self.index = 0;
        self.status.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for MutateRowsResponse_Entry {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for MutateRowsResponse_Entry {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CheckAndMutateRowRequest {
    // message fields
    pub table_name: ::std::string::String,
    pub app_profile_id: ::std::string::String,
    pub row_key: ::std::vec::Vec<u8>,
    pub predicate_filter: ::protobuf::SingularPtrField<super::data::RowFilter>,
    pub true_mutations: ::protobuf::RepeatedField<super::data::Mutation>,
    pub false_mutations: ::protobuf::RepeatedField<super::data::Mutation>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CheckAndMutateRowRequest {
    fn default() -> &'a CheckAndMutateRowRequest {
        <CheckAndMutateRowRequest as ::protobuf::Message>::default_instance()
    }
}

impl CheckAndMutateRowRequest {
    pub fn new() -> CheckAndMutateRowRequest {
        ::std::default::Default::default()
    }

    // string table_name = 1;


    pub fn get_table_name(&self) -> &str {
        &self.table_name
    }
    pub fn clear_table_name(&mut self) {
        self.table_name.clear();
    }

    // Param is passed by value, moved
    pub fn set_table_name(&mut self, v: ::std::string::String) {
        self.table_name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_table_name(&mut self) -> &mut ::std::string::String {
        &mut self.table_name
    }

    // Take field
    pub fn take_table_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.table_name, ::std::string::String::new())
    }

    // string app_profile_id = 7;


    pub fn get_app_profile_id(&self) -> &str {
        &self.app_profile_id
    }
    pub fn clear_app_profile_id(&mut self) {
        self.app_profile_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_app_profile_id(&mut self, v: ::std::string::String) {
        self.app_profile_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_app_profile_id(&mut self) -> &mut ::std::string::String {
        &mut self.app_profile_id
    }

    // Take field
    pub fn take_app_profile_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.app_profile_id, ::std::string::String::new())
    }

    // bytes row_key = 2;


    pub fn get_row_key(&self) -> &[u8] {
        &self.row_key
    }
    pub fn clear_row_key(&mut self) {
        self.row_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_row_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.row_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.row_key
    }

    // Take field
    pub fn take_row_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new())
    }

    // .google.bigtable.v2.RowFilter predicate_filter = 6;


    pub fn get_predicate_filter(&self) -> &super::data::RowFilter {
        self.predicate_filter.as_ref().unwrap_or_else(|| <super::data::RowFilter as ::protobuf::Message>::default_instance())
    }
    pub fn clear_predicate_filter(&mut self) {
        self.predicate_filter.clear();
    }

    pub fn has_predicate_filter(&self) -> bool {
        self.predicate_filter.is_some()
    }

    // Param is passed by value, moved
    pub fn set_predicate_filter(&mut self, v: super::data::RowFilter) {
        self.predicate_filter = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_predicate_filter(&mut self) -> &mut super::data::RowFilter {
        if self.predicate_filter.is_none() {
            self.predicate_filter.set_default();
        }
        self.predicate_filter.as_mut().unwrap()
    }

    // Take field
    pub fn take_predicate_filter(&mut self) -> super::data::RowFilter {
        self.predicate_filter.take().unwrap_or_else(|| super::data::RowFilter::new())
    }

    // repeated .google.bigtable.v2.Mutation true_mutations = 4;


    pub fn get_true_mutations(&self) -> &[super::data::Mutation] {
        &self.true_mutations
    }
    pub fn clear_true_mutations(&mut self) {
        self.true_mutations.clear();
    }

    // Param is passed by value, moved
    pub fn set_true_mutations(&mut self, v: ::protobuf::RepeatedField<super::data::Mutation>) {
        self.true_mutations = v;
    }

    // Mutable pointer to the field.
    pub fn mut_true_mutations(&mut self) -> &mut ::protobuf::RepeatedField<super::data::Mutation> {
        &mut self.true_mutations
    }

    // Take field
    pub fn take_true_mutations(&mut self) -> ::protobuf::RepeatedField<super::data::Mutation> {
        ::std::mem::replace(&mut self.true_mutations, ::protobuf::RepeatedField::new())
    }

    // repeated .google.bigtable.v2.Mutation false_mutations = 5;


    pub fn get_false_mutations(&self) -> &[super::data::Mutation] {
        &self.false_mutations
    }
    pub fn clear_false_mutations(&mut self) {
        self.false_mutations.clear();
    }

    // Param is passed by value, moved
    pub fn set_false_mutations(&mut self, v: ::protobuf::RepeatedField<super::data::Mutation>) {
        self.false_mutations = v;
    }

    // Mutable pointer to the field.
    pub fn mut_false_mutations(&mut self) -> &mut ::protobuf::RepeatedField<super::data::Mutation> {
        &mut self.false_mutations
    }

    // Take field
    pub fn take_false_mutations(&mut self) -> ::protobuf::RepeatedField<super::data::Mutation> {
        ::std::mem::replace(&mut self.false_mutations, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for CheckAndMutateRowRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.predicate_filter {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.true_mutations {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.false_mutations {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.app_profile_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.predicate_filter)?;
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.true_mutations)?;
                },
                5 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.false_mutations)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.table_name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.table_name);
        }
        if !self.app_profile_id.is_empty() {
            my_size += ::protobuf::rt::string_size(7, &self.app_profile_id);
        }
        if !self.row_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.row_key);
        }
        if let Some(ref v) = self.predicate_filter.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.true_mutations {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        for value in &self.false_mutations {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.table_name.is_empty() {
            os.write_string(1, &self.table_name)?;
        }
        if !self.app_profile_id.is_empty() {
            os.write_string(7, &self.app_profile_id)?;
        }
        if !self.row_key.is_empty() {
            os.write_bytes(2, &self.row_key)?;
        }
        if let Some(ref v) = self.predicate_filter.as_ref() {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        for v in &self.true_mutations {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        for v in &self.false_mutations {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CheckAndMutateRowRequest {
        CheckAndMutateRowRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "table_name",
                |m: &CheckAndMutateRowRequest| { &m.table_name },
                |m: &mut CheckAndMutateRowRequest| { &mut m.table_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "app_profile_id",
                |m: &CheckAndMutateRowRequest| { &m.app_profile_id },
                |m: &mut CheckAndMutateRowRequest| { &mut m.app_profile_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "row_key",
                |m: &CheckAndMutateRowRequest| { &m.row_key },
                |m: &mut CheckAndMutateRowRequest| { &mut m.row_key },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::data::RowFilter>>(
                "predicate_filter",
                |m: &CheckAndMutateRowRequest| { &m.predicate_filter },
                |m: &mut CheckAndMutateRowRequest| { &mut m.predicate_filter },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::data::Mutation>>(
                "true_mutations",
                |m: &CheckAndMutateRowRequest| { &m.true_mutations },
                |m: &mut CheckAndMutateRowRequest| { &mut m.true_mutations },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::data::Mutation>>(
                "false_mutations",
                |m: &CheckAndMutateRowRequest| { &m.false_mutations },
                |m: &mut CheckAndMutateRowRequest| { &mut m.false_mutations },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CheckAndMutateRowRequest>(
                "CheckAndMutateRowRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CheckAndMutateRowRequest {
        static instance: ::protobuf::rt::LazyV2<CheckAndMutateRowRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CheckAndMutateRowRequest::new)
    }
}

impl ::protobuf::Clear for CheckAndMutateRowRequest {
    fn clear(&mut self) {
        self.table_name.clear();
        self.app_profile_id.clear();
        self.row_key.clear();
        self.predicate_filter.clear();
        self.true_mutations.clear();
        self.false_mutations.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CheckAndMutateRowRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CheckAndMutateRowRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CheckAndMutateRowResponse {
    // message fields
    pub predicate_matched: bool,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CheckAndMutateRowResponse {
    fn default() -> &'a CheckAndMutateRowResponse {
        <CheckAndMutateRowResponse as ::protobuf::Message>::default_instance()
    }
}

impl CheckAndMutateRowResponse {
    pub fn new() -> CheckAndMutateRowResponse {
        ::std::default::Default::default()
    }

    // bool predicate_matched = 1;


    pub fn get_predicate_matched(&self) -> bool {
        self.predicate_matched
    }
    pub fn clear_predicate_matched(&mut self) {
        self.predicate_matched = false;
    }

    // Param is passed by value, moved
    pub fn set_predicate_matched(&mut self, v: bool) {
        self.predicate_matched = v;
    }
}

impl ::protobuf::Message for CheckAndMutateRowResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.predicate_matched = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.predicate_matched != false {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.predicate_matched != false {
            os.write_bool(1, self.predicate_matched)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CheckAndMutateRowResponse {
        CheckAndMutateRowResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "predicate_matched",
                |m: &CheckAndMutateRowResponse| { &m.predicate_matched },
                |m: &mut CheckAndMutateRowResponse| { &mut m.predicate_matched },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CheckAndMutateRowResponse>(
                "CheckAndMutateRowResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CheckAndMutateRowResponse {
        static instance: ::protobuf::rt::LazyV2<CheckAndMutateRowResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CheckAndMutateRowResponse::new)
    }
}

impl ::protobuf::Clear for CheckAndMutateRowResponse {
    fn clear(&mut self) {
        self.predicate_matched = false;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CheckAndMutateRowResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CheckAndMutateRowResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ReadModifyWriteRowRequest {
    // message fields
    pub table_name: ::std::string::String,
    pub app_profile_id: ::std::string::String,
    pub row_key: ::std::vec::Vec<u8>,
    pub rules: ::protobuf::RepeatedField<super::data::ReadModifyWriteRule>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ReadModifyWriteRowRequest {
    fn default() -> &'a ReadModifyWriteRowRequest {
        <ReadModifyWriteRowRequest as ::protobuf::Message>::default_instance()
    }
}

impl ReadModifyWriteRowRequest {
    pub fn new() -> ReadModifyWriteRowRequest {
        ::std::default::Default::default()
    }

    // string table_name = 1;


    pub fn get_table_name(&self) -> &str {
        &self.table_name
    }
    pub fn clear_table_name(&mut self) {
        self.table_name.clear();
    }

    // Param is passed by value, moved
    pub fn set_table_name(&mut self, v: ::std::string::String) {
        self.table_name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_table_name(&mut self) -> &mut ::std::string::String {
        &mut self.table_name
    }

    // Take field
    pub fn take_table_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.table_name, ::std::string::String::new())
    }

    // string app_profile_id = 4;


    pub fn get_app_profile_id(&self) -> &str {
        &self.app_profile_id
    }
    pub fn clear_app_profile_id(&mut self) {
        self.app_profile_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_app_profile_id(&mut self, v: ::std::string::String) {
        self.app_profile_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_app_profile_id(&mut self) -> &mut ::std::string::String {
        &mut self.app_profile_id
    }

    // Take field
    pub fn take_app_profile_id(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.app_profile_id, ::std::string::String::new())
    }

    // bytes row_key = 2;


    pub fn get_row_key(&self) -> &[u8] {
        &self.row_key
    }
    pub fn clear_row_key(&mut self) {
        self.row_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_row_key(&mut self, v: ::std::vec::Vec<u8>) {
        self.row_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_row_key(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.row_key
    }

    // Take field
    pub fn take_row_key(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.row_key, ::std::vec::Vec::new())
    }

    // repeated .google.bigtable.v2.ReadModifyWriteRule rules = 3;


    pub fn get_rules(&self) -> &[super::data::ReadModifyWriteRule] {
        &self.rules
    }
    pub fn clear_rules(&mut self) {
        self.rules.clear();
    }

    // Param is passed by value, moved
    pub fn set_rules(&mut self, v: ::protobuf::RepeatedField<super::data::ReadModifyWriteRule>) {
        self.rules = v;
    }

    // Mutable pointer to the field.
    pub fn mut_rules(&mut self) -> &mut ::protobuf::RepeatedField<super::data::ReadModifyWriteRule> {
        &mut self.rules
    }

    // Take field
    pub fn take_rules(&mut self) -> ::protobuf::RepeatedField<super::data::ReadModifyWriteRule> {
        ::std::mem::replace(&mut self.rules, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for ReadModifyWriteRowRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.rules {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_name)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.app_profile_id)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.row_key)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.rules)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.table_name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.table_name);
        }
        if !self.app_profile_id.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.app_profile_id);
        }
        if !self.row_key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.row_key);
        }
        for value in &self.rules {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.table_name.is_empty() {
            os.write_string(1, &self.table_name)?;
        }
        if !self.app_profile_id.is_empty() {
            os.write_string(4, &self.app_profile_id)?;
        }
        if !self.row_key.is_empty() {
            os.write_bytes(2, &self.row_key)?;
        }
        for v in &self.rules {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ReadModifyWriteRowRequest {
        ReadModifyWriteRowRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "table_name",
                |m: &ReadModifyWriteRowRequest| { &m.table_name },
                |m: &mut ReadModifyWriteRowRequest| { &mut m.table_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "app_profile_id",
                |m: &ReadModifyWriteRowRequest| { &m.app_profile_id },
                |m: &mut ReadModifyWriteRowRequest| { &mut m.app_profile_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "row_key",
                |m: &ReadModifyWriteRowRequest| { &m.row_key },
                |m: &mut ReadModifyWriteRowRequest| { &mut m.row_key },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::data::ReadModifyWriteRule>>(
                "rules",
                |m: &ReadModifyWriteRowRequest| { &m.rules },
                |m: &mut ReadModifyWriteRowRequest| { &mut m.rules },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ReadModifyWriteRowRequest>(
                "ReadModifyWriteRowRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ReadModifyWriteRowRequest {
        static instance: ::protobuf::rt::LazyV2<ReadModifyWriteRowRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ReadModifyWriteRowRequest::new)
    }
}

impl ::protobuf::Clear for ReadModifyWriteRowRequest {
    fn clear(&mut self) {
        self.table_name.clear();
        self.app_profile_id.clear();
        self.row_key.clear();
        self.rules.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ReadModifyWriteRowRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ReadModifyWriteRowRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ReadModifyWriteRowResponse {
    // message fields
    pub row: ::protobuf::SingularPtrField<super::data::Row>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ReadModifyWriteRowResponse {
    fn default() -> &'a ReadModifyWriteRowResponse {
        <ReadModifyWriteRowResponse as ::protobuf::Message>::default_instance()
    }
}

impl ReadModifyWriteRowResponse {
    pub fn new() -> ReadModifyWriteRowResponse {
        ::std::default::Default::default()
    }

    // .google.bigtable.v2.Row row = 1;


    pub fn get_row(&self) -> &super::data::Row {
        self.row.as_ref().unwrap_or_else(|| <super::data::Row as ::protobuf::Message>::default_instance())
    }
    pub fn clear_row(&mut self) {
        self.row.clear();
    }

    pub fn has_row(&self) -> bool {
        self.row.is_some()
    }

    // Param is passed by value, moved
    pub fn set_row(&mut self, v: super::data::Row) {
        self.row = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_row(&mut self) -> &mut super::data::Row {
        if self.row.is_none() {
            self.row.set_default();
        }
        self.row.as_mut().unwrap()
    }

    // Take field
    pub fn take_row(&mut self) -> super::data::Row {
        self.row.take().unwrap_or_else(|| super::data::Row::new())
    }
}

impl ::protobuf::Message for ReadModifyWriteRowResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.row {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.row)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.row.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.row.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ReadModifyWriteRowResponse {
        ReadModifyWriteRowResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::data::Row>>(
                "row",
                |m: &ReadModifyWriteRowResponse| { &m.row },
                |m: &mut ReadModifyWriteRowResponse| { &mut m.row },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ReadModifyWriteRowResponse>(
                "ReadModifyWriteRowResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ReadModifyWriteRowResponse {
        static instance: ::protobuf::rt::LazyV2<ReadModifyWriteRowResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ReadModifyWriteRowResponse::new)
    }
}

impl ::protobuf::Clear for ReadModifyWriteRowResponse {
    fn clear(&mut self) {
        self.row.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ReadModifyWriteRowResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ReadModifyWriteRowResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n!google/bigtable/v2/bigtable.proto\x12\x12google.bigtable.v2\x1a\x1cgo\
    ogle/api/annotations.proto\x1a\x17google/api/client.proto\x1a\x1fgoogle/\
    api/field_behavior.proto\x1a\x19google/api/resource.proto\x1a\x1dgoogle/\
    bigtable/v2/data.proto\x1a\x1egoogle/protobuf/wrappers.proto\x1a\x17goog\
    le/rpc/status.proto\"\x83\x02\n\x0fReadRowsRequest\x12D\n\ntable_name\
    \x18\x01\x20\x01(\tR\ttableNameB%\xfaA\x1f\n\x1dbigtable.googleapis.com/\
    Table\xe0A\x02\x12$\n\x0eapp_profile_id\x18\x05\x20\x01(\tR\x0cappProfil\
    eId\x12.\n\x04rows\x18\x02\x20\x01(\x0b2\x1a.google.bigtable.v2.RowSetR\
    \x04rows\x125\n\x06filter\x18\x03\x20\x01(\x0b2\x1d.google.bigtable.v2.R\
    owFilterR\x06filter\x12\x1d\n\nrows_limit\x18\x04\x20\x01(\x03R\trowsLim\
    it\"\xf2\x03\n\x10ReadRowsResponse\x12F\n\x06chunks\x18\x01\x20\x03(\x0b\
    2..google.bigtable.v2.ReadRowsResponse.CellChunkR\x06chunks\x12/\n\x14la\
    st_scanned_row_key\x18\x02\x20\x01(\x0cR\x11lastScannedRowKey\x1a\xe4\
    \x02\n\tCellChunk\x12\x17\n\x07row_key\x18\x01\x20\x01(\x0cR\x06rowKey\
    \x12=\n\x0bfamily_name\x18\x02\x20\x01(\x0b2\x1c.google.protobuf.StringV\
    alueR\nfamilyName\x129\n\tqualifier\x18\x03\x20\x01(\x0b2\x1b.google.pro\
    tobuf.BytesValueR\tqualifier\x12)\n\x10timestamp_micros\x18\x04\x20\x01(\
    \x03R\x0ftimestampMicros\x12\x16\n\x06labels\x18\x05\x20\x03(\tR\x06labe\
    ls\x12\x14\n\x05value\x18\x06\x20\x01(\x0cR\x05value\x12\x1d\n\nvalue_si\
    ze\x18\x07\x20\x01(\x05R\tvalueSize\x12\x1d\n\treset_row\x18\x08\x20\x01\
    (\x08H\0R\x08resetRow\x12\x1f\n\ncommit_row\x18\t\x20\x01(\x08H\0R\tcomm\
    itRowB\x0c\n\nrow_status\"\x82\x01\n\x14SampleRowKeysRequest\x12D\n\ntab\
    le_name\x18\x01\x20\x01(\tR\ttableNameB%\xfaA\x1f\n\x1dbigtable.googleap\
    is.com/Table\xe0A\x02\x12$\n\x0eapp_profile_id\x18\x02\x20\x01(\tR\x0cap\
    pProfileId\"S\n\x15SampleRowKeysResponse\x12\x17\n\x07row_key\x18\x01\
    \x20\x01(\x0cR\x06rowKey\x12!\n\x0coffset_bytes\x18\x02\x20\x01(\x03R\
    \x0boffsetBytes\"\xdd\x01\n\x10MutateRowRequest\x12D\n\ntable_name\x18\
    \x01\x20\x01(\tR\ttableNameB%\xfaA\x1f\n\x1dbigtable.googleapis.com/Tabl\
    e\xe0A\x02\x12$\n\x0eapp_profile_id\x18\x04\x20\x01(\tR\x0cappProfileId\
    \x12\x1c\n\x07row_key\x18\x02\x20\x01(\x0cR\x06rowKeyB\x03\xe0A\x02\x12?\
    \n\tmutations\x18\x03\x20\x03(\x0b2\x1c.google.bigtable.v2.MutationR\tmu\
    tationsB\x03\xe0A\x02\"\x13\n\x11MutateRowResponse\"\xae\x02\n\x11Mutate\
    RowsRequest\x12D\n\ntable_name\x18\x01\x20\x01(\tR\ttableNameB%\xfaA\x1f\
    \n\x1dbigtable.googleapis.com/Table\xe0A\x02\x12$\n\x0eapp_profile_id\
    \x18\x03\x20\x01(\tR\x0cappProfileId\x12J\n\x07entries\x18\x02\x20\x03(\
    \x0b2+.google.bigtable.v2.MutateRowsRequest.EntryR\x07entriesB\x03\xe0A\
    \x02\x1aa\n\x05Entry\x12\x17\n\x07row_key\x18\x01\x20\x01(\x0cR\x06rowKe\
    y\x12?\n\tmutations\x18\x02\x20\x03(\x0b2\x1c.google.bigtable.v2.Mutatio\
    nR\tmutationsB\x03\xe0A\x02\"\xa7\x01\n\x12MutateRowsResponse\x12F\n\x07\
    entries\x18\x01\x20\x03(\x0b2,.google.bigtable.v2.MutateRowsResponse.Ent\
    ryR\x07entries\x1aI\n\x05Entry\x12\x14\n\x05index\x18\x01\x20\x01(\x03R\
    \x05index\x12*\n\x06status\x18\x02\x20\x01(\x0b2\x12.google.rpc.StatusR\
    \x06status\"\xfa\x02\n\x18CheckAndMutateRowRequest\x12D\n\ntable_name\
    \x18\x01\x20\x01(\tR\ttableNameB%\xfaA\x1f\n\x1dbigtable.googleapis.com/\
    Table\xe0A\x02\x12$\n\x0eapp_profile_id\x18\x07\x20\x01(\tR\x0cappProfil\
    eId\x12\x1c\n\x07row_key\x18\x02\x20\x01(\x0cR\x06rowKeyB\x03\xe0A\x02\
    \x12H\n\x10predicate_filter\x18\x06\x20\x01(\x0b2\x1d.google.bigtable.v2\
    .RowFilterR\x0fpredicateFilter\x12C\n\x0etrue_mutations\x18\x04\x20\x03(\
    \x0b2\x1c.google.bigtable.v2.MutationR\rtrueMutations\x12E\n\x0ffalse_mu\
    tations\x18\x05\x20\x03(\x0b2\x1c.google.bigtable.v2.MutationR\x0efalseM\
    utations\"H\n\x19CheckAndMutateRowResponse\x12+\n\x11predicate_matched\
    \x18\x01\x20\x01(\x08R\x10predicateMatched\"\xe9\x01\n\x19ReadModifyWrit\
    eRowRequest\x12D\n\ntable_name\x18\x01\x20\x01(\tR\ttableNameB%\xfaA\x1f\
    \n\x1dbigtable.googleapis.com/Table\xe0A\x02\x12$\n\x0eapp_profile_id\
    \x18\x04\x20\x01(\tR\x0cappProfileId\x12\x1c\n\x07row_key\x18\x02\x20\
    \x01(\x0cR\x06rowKeyB\x03\xe0A\x02\x12B\n\x05rules\x18\x03\x20\x03(\x0b2\
    '.google.bigtable.v2.ReadModifyWriteRuleR\x05rulesB\x03\xe0A\x02\"G\n\
    \x1aReadModifyWriteRowResponse\x12)\n\x03row\x18\x01\x20\x01(\x0b2\x17.g\
    oogle.bigtable.v2.RowR\x03row2\xc4\x0e\n\x08Bigtable\x12\xc6\x01\n\x08Re\
    adRows\x12#.google.bigtable.v2.ReadRowsRequest\x1a$.google.bigtable.v2.R\
    eadRowsResponse\"m\x82\xd3\xe4\x93\x02>\"9/v2/{table_name=projects/*/ins\
    tances/*/tables/*}:readRows:\x01*\xdaA\ntable_name\xdaA\x19table_name,ap\
    p_profile_id0\x01\x12\xd7\x01\n\rSampleRowKeys\x12(.google.bigtable.v2.S\
    ampleRowKeysRequest\x1a).google.bigtable.v2.SampleRowKeysResponse\"o\x82\
    \xd3\xe4\x93\x02@\x12>/v2/{table_name=projects/*/instances/*/tables/*}:s\
    ampleRowKeys\xdaA\ntable_name\xdaA\x19table_name,app_profile_id0\x01\x12\
    \xed\x01\n\tMutateRow\x12$.google.bigtable.v2.MutateRowRequest\x1a%.goog\
    le.bigtable.v2.MutateRowResponse\"\x92\x01\x82\xd3\xe4\x93\x02?\":/v2/{t\
    able_name=projects/*/instances/*/tables/*}:mutateRow:\x01*\xdaA\x1ctable\
    _name,row_key,mutations\xdaA+table_name,row_key,mutations,app_profile_id\
    \x12\xde\x01\n\nMutateRows\x12%.google.bigtable.v2.MutateRowsRequest\x1a\
    &.google.bigtable.v2.MutateRowsResponse\"\x7f\x82\xd3\xe4\x93\x02@\";/v2\
    /{table_name=projects/*/instances/*/tables/*}:mutateRows:\x01*\xdaA\x12t\
    able_name,entries\xdaA!table_name,entries,app_profile_id0\x01\x12\xd9\
    \x02\n\x11CheckAndMutateRow\x12,.google.bigtable.v2.CheckAndMutateRowReq\
    uest\x1a-.google.bigtable.v2.CheckAndMutateRowResponse\"\xe6\x01\x82\xd3\
    \xe4\x93\x02G\"B/v2/{table_name=projects/*/instances/*/tables/*}:checkAn\
    dMutateRow:\x01*\xdaABtable_name,row_key,predicate_filter,true_mutations\
    ,false_mutations\xdaAQtable_name,row_key,predicate_filter,true_mutations\
    ,false_mutations,app_profile_id\x12\x89\x02\n\x12ReadModifyWriteRow\x12-\
    .google.bigtable.v2.ReadModifyWriteRowRequest\x1a..google.bigtable.v2.Re\
    adModifyWriteRowResponse\"\x93\x01\x82\xd3\xe4\x93\x02H\"C/v2/{table_nam\
    e=projects/*/instances/*/tables/*}:readModifyWriteRow:\x01*\xdaA\x18tabl\
    e_name,row_key,rules\xdaA'table_name,row_key,rules,app_profile_id\x1a\
    \xdb\x02\xd2A\xbd\x02https://www.googleapis.com/auth/bigtable.data,https\
    ://www.googleapis.com/auth/bigtable.data.readonly,https://www.googleapis\
    .com/auth/cloud-bigtable.data,https://www.googleapis.com/auth/cloud-bigt\
    able.data.readonly,https://www.googleapis.com/auth/cloud-platform,https:\
    //www.googleapis.com/auth/cloud-platform.read-only\xcaA\x17bigtable.goog\
    leapis.comB\xf5\x01\n\x16com.google.bigtable.v2B\rBigtableProtoP\x01Z:go\
    ogle.golang.org/genproto/googleapis/bigtable/v2;bigtable\xaa\x02\x18Goog\
    le.Cloud.Bigtable.V2\xca\x02\x18Google\\Cloud\\Bigtable\\V2\xeaAW\n\x1db\
    igtable.googleapis.com/Table\x126projects/{project}/instances/{instance}\
    /tables/{table}J\xd2\x81\x01\n\x07\x12\x05\x0e\0\xbb\x03\x01\n\xbd\x04\n\
    \x01\x0c\x12\x03\x0e\0\x122\xb2\x04\x20Copyright\x202019\x20Google\x20LL\
    C.\n\n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202\
    .0\x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20fil\
    e\x20except\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20m\
    ay\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\
    \x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20requ\
    ired\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\
    \x20software\n\x20distributed\x20under\x20the\x20License\x20is\x20distri\
    buted\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\
    \x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\
    \x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20lan\
    guage\x20governing\x20permissions\x20and\n\x20limitations\x20under\x20th\
    e\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0\x1b\n\t\n\x02\x03\0\x12\
    \x03\x12\0&\n\t\n\x02\x03\x01\x12\x03\x13\0!\n\t\n\x02\x03\x02\x12\x03\
    \x14\0)\n\t\n\x02\x03\x03\x12\x03\x15\0#\n\t\n\x02\x03\x04\x12\x03\x16\0\
    '\n\t\n\x02\x03\x05\x12\x03\x17\0(\n\t\n\x02\x03\x06\x12\x03\x18\0!\n\
    \x08\n\x01\x08\x12\x03\x1a\05\n\t\n\x02\x08%\x12\x03\x1a\05\n\x08\n\x01\
    \x08\x12\x03\x1b\0Q\n\t\n\x02\x08\x0b\x12\x03\x1b\0Q\n\x08\n\x01\x08\x12\
    \x03\x1c\0\"\n\t\n\x02\x08\n\x12\x03\x1c\0\"\n\x08\n\x01\x08\x12\x03\x1d\
    \0.\n\t\n\x02\x08\x08\x12\x03\x1d\0.\n\x08\n\x01\x08\x12\x03\x1e\0/\n\t\
    \n\x02\x08\x01\x12\x03\x1e\0/\n\x08\n\x01\x08\x12\x03\x1f\05\n\t\n\x02\
    \x08)\x12\x03\x1f\05\n\t\n\x01\x08\x12\x04\x20\0#\x02\n\x0c\n\x04\x08\
    \x9d\x08\0\x12\x04\x20\0#\x02\nO\n\x02\x06\0\x12\x04&\0x\x01\x1aC\x20Ser\
    vice\x20for\x20reading\x20from\x20and\x20writing\x20to\x20existing\x20Bi\
    gtable\x20tables.\n\n\n\n\x03\x06\0\x01\x12\x03&\x08\x10\n\n\n\x03\x06\0\
    \x03\x12\x03'\x02?\n\x0c\n\x05\x06\0\x03\x99\x08\x12\x03'\x02?\n\x0b\n\
    \x03\x06\0\x03\x12\x04(\x02.A\n\r\n\x05\x06\0\x03\x9a\x08\x12\x04(\x02.A\
    \n\xc1\x02\n\x04\x06\0\x02\0\x12\x045\x02<\x03\x1a\xb2\x02\x20Streams\
    \x20back\x20the\x20contents\x20of\x20all\x20requested\x20rows\x20in\x20k\
    ey\x20order,\x20optionally\n\x20applying\x20the\x20same\x20Reader\x20fil\
    ter\x20to\x20each.\x20Depending\x20on\x20their\x20size,\n\x20rows\x20and\
    \x20cells\x20may\x20be\x20broken\x20up\x20across\x20multiple\x20response\
    s,\x20but\n\x20atomicity\x20of\x20each\x20row\x20will\x20still\x20be\x20\
    preserved.\x20See\x20the\n\x20ReadRowsResponse\x20documentation\x20for\
    \x20details.\n\n\x0c\n\x05\x06\0\x02\0\x01\x12\x035\x06\x0e\n\x0c\n\x05\
    \x06\0\x02\0\x02\x12\x035\x0f\x1e\n\x0c\n\x05\x06\0\x02\0\x06\x12\x035)/\
    \n\x0c\n\x05\x06\0\x02\0\x03\x12\x0350@\n\r\n\x05\x06\0\x02\0\x04\x12\
    \x046\x049\x06\n\x11\n\t\x06\0\x02\0\x04\xb0\xca\xbc\"\x12\x046\x049\x06\
    \n\x0c\n\x05\x06\0\x02\0\x04\x12\x03:\x048\n\x0f\n\x08\x06\0\x02\0\x04\
    \x9b\x08\0\x12\x03:\x048\n\x0c\n\x05\x06\0\x02\0\x04\x12\x03;\x04G\n\x0f\
    \n\x08\x06\0\x02\0\x04\x9b\x08\x01\x12\x03;\x04G\n\xed\x01\n\x04\x06\0\
    \x02\x01\x12\x04B\x02H\x03\x1a\xde\x01\x20Returns\x20a\x20sample\x20of\
    \x20row\x20keys\x20in\x20the\x20table.\x20The\x20returned\x20row\x20keys\
    \x20will\n\x20delimit\x20contiguous\x20sections\x20of\x20the\x20table\
    \x20of\x20approximately\x20equal\x20size,\n\x20which\x20can\x20be\x20use\
    d\x20to\x20break\x20up\x20the\x20data\x20for\x20distributed\x20tasks\x20\
    like\n\x20mapreduces.\n\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x03B\x06\x13\n\
    \x0c\n\x05\x06\0\x02\x01\x02\x12\x03B\x14(\n\x0c\n\x05\x06\0\x02\x01\x06\
    \x12\x03B39\n\x0c\n\x05\x06\0\x02\x01\x03\x12\x03B:O\n\r\n\x05\x06\0\x02\
    \x01\x04\x12\x04C\x04E\x06\n\x11\n\t\x06\0\x02\x01\x04\xb0\xca\xbc\"\x12\
    \x04C\x04E\x06\n\x0c\n\x05\x06\0\x02\x01\x04\x12\x03F\x048\n\x0f\n\x08\
    \x06\0\x02\x01\x04\x9b\x08\0\x12\x03F\x048\n\x0c\n\x05\x06\0\x02\x01\x04\
    \x12\x03G\x04G\n\x0f\n\x08\x06\0\x02\x01\x04\x9b\x08\x01\x12\x03G\x04G\n\
    \x87\x01\n\x04\x06\0\x02\x02\x12\x04L\x02S\x03\x1ay\x20Mutates\x20a\x20r\
    ow\x20atomically.\x20Cells\x20already\x20present\x20in\x20the\x20row\x20\
    are\x20left\n\x20unchanged\x20unless\x20explicitly\x20changed\x20by\x20`\
    mutation`.\n\n\x0c\n\x05\x06\0\x02\x02\x01\x12\x03L\x06\x0f\n\x0c\n\x05\
    \x06\0\x02\x02\x02\x12\x03L\x10\x20\n\x0c\n\x05\x06\0\x02\x02\x03\x12\
    \x03L+<\n\r\n\x05\x06\0\x02\x02\x04\x12\x04M\x04P\x06\n\x11\n\t\x06\0\
    \x02\x02\x04\xb0\xca\xbc\"\x12\x04M\x04P\x06\n\x0c\n\x05\x06\0\x02\x02\
    \x04\x12\x03Q\x04J\n\x0f\n\x08\x06\0\x02\x02\x04\x9b\x08\0\x12\x03Q\x04J\
    \n\x0c\n\x05\x06\0\x02\x02\x04\x12\x03R\x04Y\n\x0f\n\x08\x06\0\x02\x02\
    \x04\x9b\x08\x01\x12\x03R\x04Y\n\xa0\x01\n\x04\x06\0\x02\x03\x12\x04X\
    \x02_\x03\x1a\x91\x01\x20Mutates\x20multiple\x20rows\x20in\x20a\x20batch\
    .\x20Each\x20individual\x20row\x20is\x20mutated\n\x20atomically\x20as\
    \x20in\x20MutateRow,\x20but\x20the\x20entire\x20batch\x20is\x20not\x20ex\
    ecuted\n\x20atomically.\n\n\x0c\n\x05\x06\0\x02\x03\x01\x12\x03X\x06\x10\
    \n\x0c\n\x05\x06\0\x02\x03\x02\x12\x03X\x11\"\n\x0c\n\x05\x06\0\x02\x03\
    \x06\x12\x03X-3\n\x0c\n\x05\x06\0\x02\x03\x03\x12\x03X4F\n\r\n\x05\x06\0\
    \x02\x03\x04\x12\x04Y\x04\\\x06\n\x11\n\t\x06\0\x02\x03\x04\xb0\xca\xbc\
    \"\x12\x04Y\x04\\\x06\n\x0c\n\x05\x06\0\x02\x03\x04\x12\x03]\x04@\n\x0f\
    \n\x08\x06\0\x02\x03\x04\x9b\x08\0\x12\x03]\x04@\n\x0c\n\x05\x06\0\x02\
    \x03\x04\x12\x03^\x04O\n\x0f\n\x08\x06\0\x02\x03\x04\x9b\x08\x01\x12\x03\
    ^\x04O\nZ\n\x04\x06\0\x02\x04\x12\x04b\x02i\x03\x1aL\x20Mutates\x20a\x20\
    row\x20atomically\x20based\x20on\x20the\x20output\x20of\x20a\x20predicat\
    e\x20Reader\x20filter.\n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\x03b\x06\x17\
    \n\x0c\n\x05\x06\0\x02\x04\x02\x12\x03b\x180\n\x0c\n\x05\x06\0\x02\x04\
    \x03\x12\x03b;T\n\r\n\x05\x06\0\x02\x04\x04\x12\x04c\x04f\x06\n\x11\n\t\
    \x06\0\x02\x04\x04\xb0\xca\xbc\"\x12\x04c\x04f\x06\n\x0c\n\x05\x06\0\x02\
    \x04\x04\x12\x03g\x04p\n\x0f\n\x08\x06\0\x02\x04\x04\x9b\x08\0\x12\x03g\
    \x04p\n\x0c\n\x05\x06\0\x02\x04\x04\x12\x03h\x04\x7f\n\x0f\n\x08\x06\0\
    \x02\x04\x04\x9b\x08\x01\x12\x03h\x04\x7f\n\xf6\x02\n\x04\x06\0\x02\x05\
    \x12\x04p\x02w\x03\x1a\xe7\x02\x20Modifies\x20a\x20row\x20atomically\x20\
    on\x20the\x20server.\x20The\x20method\x20reads\x20the\x20latest\n\x20exi\
    sting\x20timestamp\x20and\x20value\x20from\x20the\x20specified\x20column\
    s\x20and\x20writes\x20a\x20new\n\x20entry\x20based\x20on\x20pre-defined\
    \x20read/modify/write\x20rules.\x20The\x20new\x20value\x20for\x20the\n\
    \x20timestamp\x20is\x20the\x20greater\x20of\x20the\x20existing\x20timest\
    amp\x20or\x20the\x20current\x20server\n\x20time.\x20The\x20method\x20ret\
    urns\x20the\x20new\x20contents\x20of\x20all\x20modified\x20cells.\n\n\
    \x0c\n\x05\x06\0\x02\x05\x01\x12\x03p\x06\x18\n\x0c\n\x05\x06\0\x02\x05\
    \x02\x12\x03p\x192\n\x0c\n\x05\x06\0\x02\x05\x03\x12\x03p=W\n\r\n\x05\
    \x06\0\x02\x05\x04\x12\x04q\x04t\x06\n\x11\n\t\x06\0\x02\x05\x04\xb0\xca\
    \xbc\"\x12\x04q\x04t\x06\n\x0c\n\x05\x06\0\x02\x05\x04\x12\x03u\x04F\n\
    \x0f\n\x08\x06\0\x02\x05\x04\x9b\x08\0\x12\x03u\x04F\n\x0c\n\x05\x06\0\
    \x02\x05\x04\x12\x03v\x04U\n\x0f\n\x08\x06\0\x02\x05\x04\x9b\x08\x01\x12\
    \x03v\x04U\n5\n\x02\x04\0\x12\x05{\0\x94\x01\x01\x1a(\x20Request\x20mess\
    age\x20for\x20Bigtable.ReadRows.\n\n\n\n\x03\x04\0\x01\x12\x03{\x08\x17\
    \n\x9f\x01\n\x04\x04\0\x02\0\x12\x05\x7f\x02\x84\x01\x04\x1a\x8f\x01\x20\
    Required.\x20The\x20unique\x20name\x20of\x20the\x20table\x20from\x20whic\
    h\x20to\x20read.\n\x20Values\x20are\x20of\x20the\x20form\n\x20`projects/\
    <project>/instances/<instance>/tables/<table>`.\n\n\x0c\n\x05\x04\0\x02\
    \0\x05\x12\x03\x7f\x02\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x7f\t\x13\
    \n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x7f\x16\x17\n\x0e\n\x05\x04\0\x02\0\
    \x08\x12\x05\x7f\x18\x84\x01\x03\n\x10\n\x08\x04\0\x02\0\x08\x9c\x08\0\
    \x12\x04\x80\x01\x04*\n\x11\n\x07\x04\0\x02\0\x08\x9f\x08\x12\x06\x81\
    \x01\x04\x83\x01\x05\n\x80\x01\n\x04\x04\0\x02\x01\x12\x04\x88\x01\x02\
    \x1c\x1ar\x20This\x20value\x20specifies\x20routing\x20for\x20replication\
    .\x20If\x20not\x20specified,\x20the\n\x20\"default\"\x20application\x20p\
    rofile\x20will\x20be\x20used.\n\n\r\n\x05\x04\0\x02\x01\x05\x12\x04\x88\
    \x01\x02\x08\n\r\n\x05\x04\0\x02\x01\x01\x12\x04\x88\x01\t\x17\n\r\n\x05\
    \x04\0\x02\x01\x03\x12\x04\x88\x01\x1a\x1b\nZ\n\x04\x04\0\x02\x02\x12\
    \x04\x8b\x01\x02\x12\x1aL\x20The\x20row\x20keys\x20and/or\x20ranges\x20t\
    o\x20read.\x20If\x20not\x20specified,\x20reads\x20from\x20all\x20rows.\n\
    \n\r\n\x05\x04\0\x02\x02\x06\x12\x04\x8b\x01\x02\x08\n\r\n\x05\x04\0\x02\
    \x02\x01\x12\x04\x8b\x01\t\r\n\r\n\x05\x04\0\x02\x02\x03\x12\x04\x8b\x01\
    \x10\x11\nw\n\x04\x04\0\x02\x03\x12\x04\x8f\x01\x02\x17\x1ai\x20The\x20f\
    ilter\x20to\x20apply\x20to\x20the\x20contents\x20of\x20the\x20specified\
    \x20row(s).\x20If\x20unset,\n\x20reads\x20the\x20entirety\x20of\x20each\
    \x20row.\n\n\r\n\x05\x04\0\x02\x03\x06\x12\x04\x8f\x01\x02\x0b\n\r\n\x05\
    \x04\0\x02\x03\x01\x12\x04\x8f\x01\x0c\x12\n\r\n\x05\x04\0\x02\x03\x03\
    \x12\x04\x8f\x01\x15\x16\n\x83\x01\n\x04\x04\0\x02\x04\x12\x04\x93\x01\
    \x02\x17\x1au\x20The\x20read\x20will\x20terminate\x20after\x20committing\
    \x20to\x20N\x20rows'\x20worth\x20of\x20results.\x20The\n\x20default\x20(\
    zero)\x20is\x20to\x20return\x20all\x20results.\n\n\r\n\x05\x04\0\x02\x04\
    \x05\x12\x04\x93\x01\x02\x07\n\r\n\x05\x04\0\x02\x04\x01\x12\x04\x93\x01\
    \x08\x12\n\r\n\x05\x04\0\x02\x04\x03\x12\x04\x93\x01\x15\x16\n7\n\x02\
    \x04\x01\x12\x06\x97\x01\0\xe6\x01\x01\x1a)\x20Response\x20message\x20fo\
    r\x20Bigtable.ReadRows.\n\n\x0b\n\x03\x04\x01\x01\x12\x04\x97\x01\x08\
    \x18\nf\n\x04\x04\x01\x03\0\x12\x06\x9a\x01\x02\xd9\x01\x03\x1aV\x20Spec\
    ifies\x20a\x20piece\x20of\x20a\x20row's\x20contents\x20returned\x20as\
    \x20part\x20of\x20the\x20read\n\x20response\x20stream.\n\n\r\n\x05\x04\
    \x01\x03\0\x01\x12\x04\x9a\x01\n\x13\n\xd7\x02\n\x06\x04\x01\x03\0\x02\0\
    \x12\x04\xa2\x01\x04\x16\x1a\xc6\x02\x20The\x20row\x20key\x20for\x20this\
    \x20chunk\x20of\x20data.\x20\x20If\x20the\x20row\x20key\x20is\x20empty,\
    \n\x20this\x20CellChunk\x20is\x20a\x20continuation\x20of\x20the\x20same\
    \x20row\x20as\x20the\x20previous\n\x20CellChunk\x20in\x20the\x20response\
    \x20stream,\x20even\x20if\x20that\x20CellChunk\x20was\x20in\x20a\n\x20pr\
    evious\x20ReadRowsResponse\x20message.\n\n\x20Classified\x20as\x20IDENTI\
    FYING_ID\x20to\x20provide\x20context\x20around\x20data\x20accesses\x20fo\
    r\n\x20auditing\x20systems.\n\n\x0f\n\x07\x04\x01\x03\0\x02\0\x05\x12\
    \x04\xa2\x01\x04\t\n\x0f\n\x07\x04\x01\x03\0\x02\0\x01\x12\x04\xa2\x01\n\
    \x11\n\x0f\n\x07\x04\x01\x03\0\x02\0\x03\x12\x04\xa2\x01\x14\x15\n\xf3\
    \x02\n\x06\x04\x01\x03\0\x02\x01\x12\x04\xaa\x01\x040\x1a\xe2\x02\x20The\
    \x20column\x20family\x20name\x20for\x20this\x20chunk\x20of\x20data.\x20\
    \x20If\x20this\x20message\n\x20is\x20not\x20present\x20this\x20CellChunk\
    \x20is\x20a\x20continuation\x20of\x20the\x20same\x20column\n\x20family\
    \x20as\x20the\x20previous\x20CellChunk.\x20\x20The\x20empty\x20string\
    \x20can\x20occur\x20as\x20a\n\x20column\x20family\x20name\x20in\x20a\x20\
    response\x20so\x20clients\x20must\x20check\n\x20explicitly\x20for\x20the\
    \x20presence\x20of\x20this\x20message,\x20not\x20just\x20for\n\x20`famil\
    y_name.value`\x20being\x20non-empty.\n\n\x0f\n\x07\x04\x01\x03\0\x02\x01\
    \x06\x12\x04\xaa\x01\x04\x1f\n\x0f\n\x07\x04\x01\x03\0\x02\x01\x01\x12\
    \x04\xaa\x01\x20+\n\x0f\n\x07\x04\x01\x03\0\x02\x01\x03\x12\x04\xaa\x01.\
    /\n\xbb\x02\n\x06\x04\x01\x03\0\x02\x02\x12\x04\xb1\x01\x04-\x1a\xaa\x02\
    \x20The\x20column\x20qualifier\x20for\x20this\x20chunk\x20of\x20data.\
    \x20\x20If\x20this\x20message\n\x20is\x20not\x20present,\x20this\x20Cell\
    Chunk\x20is\x20a\x20continuation\x20of\x20the\x20same\x20column\n\x20as\
    \x20the\x20previous\x20CellChunk.\x20\x20Column\x20qualifiers\x20may\x20\
    be\x20empty\x20so\n\x20clients\x20must\x20check\x20for\x20the\x20presenc\
    e\x20of\x20this\x20message,\x20not\x20just\n\x20for\x20`qualifier.value`\
    \x20being\x20non-empty.\n\n\x0f\n\x07\x04\x01\x03\0\x02\x02\x06\x12\x04\
    \xb1\x01\x04\x1e\n\x0f\n\x07\x04\x01\x03\0\x02\x02\x01\x12\x04\xb1\x01\
    \x1f(\n\x0f\n\x07\x04\x01\x03\0\x02\x02\x03\x12\x04\xb1\x01+,\n\xdd\x03\
    \n\x06\x04\x01\x03\0\x02\x03\x12\x04\xbb\x01\x04\x1f\x1a\xcc\x03\x20The\
    \x20cell's\x20stored\x20timestamp,\x20which\x20also\x20uniquely\x20ident\
    ifies\x20it\n\x20within\x20its\x20column.\x20\x20Values\x20are\x20always\
    \x20expressed\x20in\n\x20microseconds,\x20but\x20individual\x20tables\
    \x20may\x20set\x20a\x20coarser\n\x20granularity\x20to\x20further\x20rest\
    rict\x20the\x20allowed\x20values.\x20For\n\x20example,\x20a\x20table\x20\
    which\x20specifies\x20millisecond\x20granularity\x20will\n\x20only\x20al\
    low\x20values\x20of\x20`timestamp_micros`\x20which\x20are\x20multiples\
    \x20of\n\x201000.\x20\x20Timestamps\x20are\x20only\x20set\x20in\x20the\
    \x20first\x20CellChunk\x20per\x20cell\n\x20(for\x20cells\x20split\x20int\
    o\x20multiple\x20chunks).\n\n\x0f\n\x07\x04\x01\x03\0\x02\x03\x05\x12\
    \x04\xbb\x01\x04\t\n\x0f\n\x07\x04\x01\x03\0\x02\x03\x01\x12\x04\xbb\x01\
    \n\x1a\n\x0f\n\x07\x04\x01\x03\0\x02\x03\x03\x12\x04\xbb\x01\x1d\x1e\n\
    \x95\x01\n\x06\x04\x01\x03\0\x02\x04\x12\x04\xc0\x01\x04\x1f\x1a\x84\x01\
    \x20Labels\x20applied\x20to\x20the\x20cell\x20by\x20a\n\x20[RowFilter][g\
    oogle.bigtable.v2.RowFilter].\x20\x20Labels\x20are\x20only\x20set\n\x20o\
    n\x20the\x20first\x20CellChunk\x20per\x20cell.\n\n\x0f\n\x07\x04\x01\x03\
    \0\x02\x04\x04\x12\x04\xc0\x01\x04\x0c\n\x0f\n\x07\x04\x01\x03\0\x02\x04\
    \x05\x12\x04\xc0\x01\r\x13\n\x0f\n\x07\x04\x01\x03\0\x02\x04\x01\x12\x04\
    \xc0\x01\x14\x1a\n\x0f\n\x07\x04\x01\x03\0\x02\x04\x03\x12\x04\xc0\x01\
    \x1d\x1e\n\xbf\x02\n\x06\x04\x01\x03\0\x02\x05\x12\x04\xc7\x01\x04\x14\
    \x1a\xae\x02\x20The\x20value\x20stored\x20in\x20the\x20cell.\x20\x20Cell\
    \x20values\x20can\x20be\x20split\x20across\n\x20multiple\x20CellChunks.\
    \x20\x20In\x20that\x20case\x20only\x20the\x20value\x20field\x20will\x20b\
    e\n\x20set\x20in\x20CellChunks\x20after\x20the\x20first:\x20the\x20times\
    tamp\x20and\x20labels\n\x20will\x20only\x20be\x20present\x20in\x20the\
    \x20first\x20CellChunk,\x20even\x20if\x20the\x20first\n\x20CellChunk\x20\
    came\x20in\x20a\x20previous\x20ReadRowsResponse.\n\n\x0f\n\x07\x04\x01\
    \x03\0\x02\x05\x05\x12\x04\xc7\x01\x04\t\n\x0f\n\x07\x04\x01\x03\0\x02\
    \x05\x01\x12\x04\xc7\x01\n\x0f\n\x0f\n\x07\x04\x01\x03\0\x02\x05\x03\x12\
    \x04\xc7\x01\x12\x13\n\x85\x02\n\x06\x04\x01\x03\0\x02\x06\x12\x04\xcd\
    \x01\x04\x19\x1a\xf4\x01\x20If\x20this\x20CellChunk\x20is\x20part\x20of\
    \x20a\x20chunked\x20cell\x20value\x20and\x20this\x20is\n\x20not\x20the\
    \x20final\x20chunk\x20of\x20that\x20cell,\x20value_size\x20will\x20be\
    \x20set\x20to\x20the\n\x20total\x20length\x20of\x20the\x20cell\x20value.\
    \x20\x20The\x20client\x20can\x20use\x20this\x20size\n\x20to\x20pre-alloc\
    ate\x20memory\x20to\x20hold\x20the\x20full\x20cell\x20value.\n\n\x0f\n\
    \x07\x04\x01\x03\0\x02\x06\x05\x12\x04\xcd\x01\x04\t\n\x0f\n\x07\x04\x01\
    \x03\0\x02\x06\x01\x12\x04\xcd\x01\n\x14\n\x0f\n\x07\x04\x01\x03\0\x02\
    \x06\x03\x12\x04\xcd\x01\x17\x18\nR\n\x06\x04\x01\x03\0\x08\0\x12\x06\
    \xd0\x01\x04\xd8\x01\x05\x1a@\x20Signals\x20to\x20the\x20client\x20conce\
    rning\x20previous\x20CellChunks\x20received.\n\n\x0f\n\x07\x04\x01\x03\0\
    \x08\0\x01\x12\x04\xd0\x01\n\x14\n\x85\x01\n\x06\x04\x01\x03\0\x02\x07\
    \x12\x04\xd3\x01\x06\x19\x1au\x20Indicates\x20that\x20the\x20client\x20s\
    hould\x20drop\x20all\x20previous\x20chunks\x20for\n\x20`row_key`,\x20as\
    \x20it\x20will\x20be\x20re-read\x20from\x20the\x20beginning.\n\n\x0f\n\
    \x07\x04\x01\x03\0\x02\x07\x05\x12\x04\xd3\x01\x06\n\n\x0f\n\x07\x04\x01\
    \x03\0\x02\x07\x01\x12\x04\xd3\x01\x0b\x14\n\x0f\n\x07\x04\x01\x03\0\x02\
    \x07\x03\x12\x04\xd3\x01\x17\x18\n\x83\x01\n\x06\x04\x01\x03\0\x02\x08\
    \x12\x04\xd7\x01\x06\x1a\x1as\x20Indicates\x20that\x20the\x20client\x20c\
    an\x20safely\x20process\x20all\x20previous\x20chunks\x20for\n\x20`row_ke\
    y`,\x20as\x20its\x20data\x20has\x20been\x20fully\x20read.\n\n\x0f\n\x07\
    \x04\x01\x03\0\x02\x08\x05\x12\x04\xd7\x01\x06\n\n\x0f\n\x07\x04\x01\x03\
    \0\x02\x08\x01\x12\x04\xd7\x01\x0b\x15\n\x0f\n\x07\x04\x01\x03\0\x02\x08\
    \x03\x12\x04\xd7\x01\x18\x19\nM\n\x04\x04\x01\x02\0\x12\x04\xdc\x01\x02\
    \x20\x1a?\x20A\x20collection\x20of\x20a\x20row's\x20contents\x20as\x20pa\
    rt\x20of\x20the\x20read\x20request.\n\n\r\n\x05\x04\x01\x02\0\x04\x12\
    \x04\xdc\x01\x02\n\n\r\n\x05\x04\x01\x02\0\x06\x12\x04\xdc\x01\x0b\x14\n\
    \r\n\x05\x04\x01\x02\0\x01\x12\x04\xdc\x01\x15\x1b\n\r\n\x05\x04\x01\x02\
    \0\x03\x12\x04\xdc\x01\x1e\x1f\n\xc5\x03\n\x04\x04\x01\x02\x01\x12\x04\
    \xe5\x01\x02!\x1a\xb6\x03\x20Optionally\x20the\x20server\x20might\x20ret\
    urn\x20the\x20row\x20key\x20of\x20the\x20last\x20row\x20it\n\x20has\x20s\
    canned.\x20\x20The\x20client\x20can\x20use\x20this\x20to\x20construct\
    \x20a\x20more\n\x20efficient\x20retry\x20request\x20if\x20needed:\x20any\
    \x20row\x20keys\x20or\x20portions\x20of\n\x20ranges\x20less\x20than\x20t\
    his\x20row\x20key\x20can\x20be\x20dropped\x20from\x20the\x20request.\n\
    \x20This\x20is\x20primarily\x20useful\x20for\x20cases\x20where\x20the\
    \x20server\x20has\x20read\x20a\n\x20lot\x20of\x20data\x20that\x20was\x20\
    filtered\x20out\x20since\x20the\x20last\x20committed\x20row\n\x20key,\
    \x20allowing\x20the\x20client\x20to\x20skip\x20that\x20work\x20on\x20a\
    \x20retry.\n\n\r\n\x05\x04\x01\x02\x01\x05\x12\x04\xe5\x01\x02\x07\n\r\n\
    \x05\x04\x01\x02\x01\x01\x12\x04\xe5\x01\x08\x1c\n\r\n\x05\x04\x01\x02\
    \x01\x03\x12\x04\xe5\x01\x1f\x20\n;\n\x02\x04\x02\x12\x06\xe9\x01\0\xf7\
    \x01\x01\x1a-\x20Request\x20message\x20for\x20Bigtable.SampleRowKeys.\n\
    \n\x0b\n\x03\x04\x02\x01\x12\x04\xe9\x01\x08\x1c\n\xab\x01\n\x04\x04\x02\
    \x02\0\x12\x06\xed\x01\x02\xf2\x01\x04\x1a\x9a\x01\x20Required.\x20The\
    \x20unique\x20name\x20of\x20the\x20table\x20from\x20which\x20to\x20sampl\
    e\x20row\x20keys.\n\x20Values\x20are\x20of\x20the\x20form\n\x20`projects\
    /<project>/instances/<instance>/tables/<table>`.\n\n\r\n\x05\x04\x02\x02\
    \0\x05\x12\x04\xed\x01\x02\x08\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\xed\
    \x01\t\x13\n\r\n\x05\x04\x02\x02\0\x03\x12\x04\xed\x01\x16\x17\n\x0f\n\
    \x05\x04\x02\x02\0\x08\x12\x06\xed\x01\x18\xf2\x01\x03\n\x10\n\x08\x04\
    \x02\x02\0\x08\x9c\x08\0\x12\x04\xee\x01\x04*\n\x11\n\x07\x04\x02\x02\0\
    \x08\x9f\x08\x12\x06\xef\x01\x04\xf1\x01\x05\n\x80\x01\n\x04\x04\x02\x02\
    \x01\x12\x04\xf6\x01\x02\x1c\x1ar\x20This\x20value\x20specifies\x20routi\
    ng\x20for\x20replication.\x20If\x20not\x20specified,\x20the\n\x20\"defau\
    lt\"\x20application\x20profile\x20will\x20be\x20used.\n\n\r\n\x05\x04\
    \x02\x02\x01\x05\x12\x04\xf6\x01\x02\x08\n\r\n\x05\x04\x02\x02\x01\x01\
    \x12\x04\xf6\x01\t\x17\n\r\n\x05\x04\x02\x02\x01\x03\x12\x04\xf6\x01\x1a\
    \x1b\n<\n\x02\x04\x03\x12\x06\xfa\x01\0\x8c\x02\x01\x1a.\x20Response\x20\
    message\x20for\x20Bigtable.SampleRowKeys.\n\n\x0b\n\x03\x04\x03\x01\x12\
    \x04\xfa\x01\x08\x1d\n\xbe\x04\n\x04\x04\x03\x02\0\x12\x04\x85\x02\x02\
    \x14\x1a\xaf\x04\x20Sorted\x20streamed\x20sequence\x20of\x20sample\x20ro\
    w\x20keys\x20in\x20the\x20table.\x20The\x20table\x20might\n\x20have\x20c\
    ontents\x20before\x20the\x20first\x20row\x20key\x20in\x20the\x20list\x20\
    and\x20after\x20the\x20last\x20one,\n\x20but\x20a\x20key\x20containing\
    \x20the\x20empty\x20string\x20indicates\x20\"end\x20of\x20table\"\x20and\
    \x20will\x20be\n\x20the\x20last\x20response\x20given,\x20if\x20present.\
    \n\x20Note\x20that\x20row\x20keys\x20in\x20this\x20list\x20may\x20not\
    \x20have\x20ever\x20been\x20written\x20to\x20or\x20read\n\x20from,\x20an\
    d\x20users\x20should\x20therefore\x20not\x20make\x20any\x20assumptions\
    \x20about\x20the\x20row\x20key\n\x20structure\x20that\x20are\x20specific\
    \x20to\x20their\x20use\x20case.\n\n\x20Classified\x20as\x20IDENTIFYING_I\
    D\x20to\x20provide\x20context\x20around\x20data\x20accesses\x20for\n\x20\
    auditing\x20systems.\n\n\r\n\x05\x04\x03\x02\0\x05\x12\x04\x85\x02\x02\
    \x07\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\x85\x02\x08\x0f\n\r\n\x05\x04\
    \x03\x02\0\x03\x12\x04\x85\x02\x12\x13\n\x80\x02\n\x04\x04\x03\x02\x01\
    \x12\x04\x8b\x02\x02\x19\x1a\xf1\x01\x20Approximate\x20total\x20storage\
    \x20space\x20used\x20by\x20all\x20rows\x20in\x20the\x20table\x20which\
    \x20precede\n\x20`row_key`.\x20Buffering\x20the\x20contents\x20of\x20all\
    \x20rows\x20between\x20two\x20subsequent\n\x20samples\x20would\x20requir\
    e\x20space\x20roughly\x20equal\x20to\x20the\x20difference\x20in\x20their\
    \n\x20`offset_bytes`\x20fields.\n\n\r\n\x05\x04\x03\x02\x01\x05\x12\x04\
    \x8b\x02\x02\x07\n\r\n\x05\x04\x03\x02\x01\x01\x12\x04\x8b\x02\x08\x14\n\
    \r\n\x05\x04\x03\x02\x01\x03\x12\x04\x8b\x02\x17\x18\n7\n\x02\x04\x04\
    \x12\x06\x8f\x02\0\xa8\x02\x01\x1a)\x20Request\x20message\x20for\x20Bigt\
    able.MutateRow.\n\n\x0b\n\x03\x04\x04\x01\x12\x04\x8f\x02\x08\x18\n\xb5\
    \x01\n\x04\x04\x04\x02\0\x12\x06\x93\x02\x02\x98\x02\x04\x1a\xa4\x01\x20\
    Required.\x20The\x20unique\x20name\x20of\x20the\x20table\x20to\x20which\
    \x20the\x20mutation\x20should\x20be\x20applied.\n\x20Values\x20are\x20of\
    \x20the\x20form\n\x20`projects/<project>/instances/<instance>/tables/<ta\
    ble>`.\n\n\r\n\x05\x04\x04\x02\0\x05\x12\x04\x93\x02\x02\x08\n\r\n\x05\
    \x04\x04\x02\0\x01\x12\x04\x93\x02\t\x13\n\r\n\x05\x04\x04\x02\0\x03\x12\
    \x04\x93\x02\x16\x17\n\x0f\n\x05\x04\x04\x02\0\x08\x12\x06\x93\x02\x18\
    \x98\x02\x03\n\x10\n\x08\x04\x04\x02\0\x08\x9c\x08\0\x12\x04\x94\x02\x04\
    *\n\x11\n\x07\x04\x04\x02\0\x08\x9f\x08\x12\x06\x95\x02\x04\x97\x02\x05\
    \n\x80\x01\n\x04\x04\x04\x02\x01\x12\x04\x9c\x02\x02\x1c\x1ar\x20This\
    \x20value\x20specifies\x20routing\x20for\x20replication.\x20If\x20not\
    \x20specified,\x20the\n\x20\"default\"\x20application\x20profile\x20will\
    \x20be\x20used.\n\n\r\n\x05\x04\x04\x02\x01\x05\x12\x04\x9c\x02\x02\x08\
    \n\r\n\x05\x04\x04\x02\x01\x01\x12\x04\x9c\x02\t\x17\n\r\n\x05\x04\x04\
    \x02\x01\x03\x12\x04\x9c\x02\x1a\x1b\n\xb4\x01\n\x04\x04\x04\x02\x02\x12\
    \x04\xa2\x02\x02=\x1a\xa5\x01\x20Required.\x20The\x20key\x20of\x20the\
    \x20row\x20to\x20which\x20the\x20mutation\x20should\x20be\x20applied.\n\
    \n\x20Classified\x20as\x20IDENTIFYING_ID\x20to\x20provide\x20context\x20\
    around\x20data\x20accesses\x20for\n\x20auditing\x20systems.\n\n\r\n\x05\
    \x04\x04\x02\x02\x05\x12\x04\xa2\x02\x02\x07\n\r\n\x05\x04\x04\x02\x02\
    \x01\x12\x04\xa2\x02\x08\x0f\n\r\n\x05\x04\x04\x02\x02\x03\x12\x04\xa2\
    \x02\x12\x13\n\r\n\x05\x04\x04\x02\x02\x08\x12\x04\xa2\x02\x14<\n\x10\n\
    \x08\x04\x04\x02\x02\x08\x9c\x08\0\x12\x04\xa2\x02\x15;\n\xe1\x01\n\x04\
    \x04\x04\x02\x03\x12\x04\xa7\x02\x02K\x1a\xd2\x01\x20Required.\x20Change\
    s\x20to\x20be\x20atomically\x20applied\x20to\x20the\x20specified\x20row.\
    \x20Entries\x20are\x20applied\n\x20in\x20order,\x20meaning\x20that\x20ea\
    rlier\x20mutations\x20can\x20be\x20masked\x20by\x20later\x20ones.\n\x20M\
    ust\x20contain\x20at\x20least\x20one\x20entry\x20and\x20at\x20most\x2010\
    0000.\n\n\r\n\x05\x04\x04\x02\x03\x04\x12\x04\xa7\x02\x02\n\n\r\n\x05\
    \x04\x04\x02\x03\x06\x12\x04\xa7\x02\x0b\x13\n\r\n\x05\x04\x04\x02\x03\
    \x01\x12\x04\xa7\x02\x14\x1d\n\r\n\x05\x04\x04\x02\x03\x03\x12\x04\xa7\
    \x02\x20!\n\r\n\x05\x04\x04\x02\x03\x08\x12\x04\xa7\x02\"J\n\x10\n\x08\
    \x04\x04\x02\x03\x08\x9c\x08\0\x12\x04\xa7\x02#I\n8\n\x02\x04\x05\x12\
    \x06\xab\x02\0\xad\x02\x01\x1a*\x20Response\x20message\x20for\x20Bigtabl\
    e.MutateRow.\n\n\x0b\n\x03\x04\x05\x01\x12\x04\xab\x02\x08\x19\n?\n\x02\
    \x04\x06\x12\x06\xb0\x02\0\xd2\x02\x01\x1a1\x20Request\x20message\x20for\
    \x20BigtableService.MutateRows.\n\n\x0b\n\x03\x04\x06\x01\x12\x04\xb0\
    \x02\x08\x19\n-\n\x04\x04\x06\x03\0\x12\x06\xb2\x02\x02\xbe\x02\x03\x1a\
    \x1d\x20A\x20mutation\x20for\x20a\x20given\x20row.\n\n\r\n\x05\x04\x06\
    \x03\0\x01\x12\x04\xb2\x02\n\x0f\n\xaf\x01\n\x06\x04\x06\x03\0\x02\0\x12\
    \x04\xb7\x02\x04\x16\x1a\x9e\x01\x20The\x20key\x20of\x20the\x20row\x20to\
    \x20which\x20the\x20`mutations`\x20should\x20be\x20applied.\n\n\x20Class\
    ified\x20as\x20IDENTIFYING_ID\x20to\x20provide\x20context\x20around\x20d\
    ata\x20accesses\x20for\n\x20auditing\x20systems.\n\n\x0f\n\x07\x04\x06\
    \x03\0\x02\0\x05\x12\x04\xb7\x02\x04\t\n\x0f\n\x07\x04\x06\x03\0\x02\0\
    \x01\x12\x04\xb7\x02\n\x11\n\x0f\n\x07\x04\x06\x03\0\x02\0\x03\x12\x04\
    \xb7\x02\x14\x15\n\xda\x01\n\x06\x04\x06\x03\0\x02\x01\x12\x04\xbd\x02\
    \x04M\x1a\xc9\x01\x20Required.\x20Changes\x20to\x20be\x20atomically\x20a\
    pplied\x20to\x20the\x20specified\x20row.\x20Mutations\x20are\n\x20applie\
    d\x20in\x20order,\x20meaning\x20that\x20earlier\x20mutations\x20can\x20b\
    e\x20masked\x20by\n\x20later\x20ones.\n\x20You\x20must\x20specify\x20at\
    \x20least\x20one\x20mutation.\n\n\x0f\n\x07\x04\x06\x03\0\x02\x01\x04\
    \x12\x04\xbd\x02\x04\x0c\n\x0f\n\x07\x04\x06\x03\0\x02\x01\x06\x12\x04\
    \xbd\x02\r\x15\n\x0f\n\x07\x04\x06\x03\0\x02\x01\x01\x12\x04\xbd\x02\x16\
    \x1f\n\x0f\n\x07\x04\x06\x03\0\x02\x01\x03\x12\x04\xbd\x02\"#\n\x0f\n\
    \x07\x04\x06\x03\0\x02\x01\x08\x12\x04\xbd\x02$L\n\x12\n\n\x04\x06\x03\0\
    \x02\x01\x08\x9c\x08\0\x12\x04\xbd\x02%K\nb\n\x04\x04\x06\x02\0\x12\x06\
    \xc1\x02\x02\xc6\x02\x04\x1aR\x20Required.\x20The\x20unique\x20name\x20o\
    f\x20the\x20table\x20to\x20which\x20the\x20mutations\x20should\x20be\x20\
    applied.\n\n\r\n\x05\x04\x06\x02\0\x05\x12\x04\xc1\x02\x02\x08\n\r\n\x05\
    \x04\x06\x02\0\x01\x12\x04\xc1\x02\t\x13\n\r\n\x05\x04\x06\x02\0\x03\x12\
    \x04\xc1\x02\x16\x17\n\x0f\n\x05\x04\x06\x02\0\x08\x12\x06\xc1\x02\x18\
    \xc6\x02\x03\n\x10\n\x08\x04\x06\x02\0\x08\x9c\x08\0\x12\x04\xc2\x02\x04\
    *\n\x11\n\x07\x04\x06\x02\0\x08\x9f\x08\x12\x06\xc3\x02\x04\xc5\x02\x05\
    \n\x80\x01\n\x04\x04\x06\x02\x01\x12\x04\xca\x02\x02\x1c\x1ar\x20This\
    \x20value\x20specifies\x20routing\x20for\x20replication.\x20If\x20not\
    \x20specified,\x20the\n\x20\"default\"\x20application\x20profile\x20will\
    \x20be\x20used.\n\n\r\n\x05\x04\x06\x02\x01\x05\x12\x04\xca\x02\x02\x08\
    \n\r\n\x05\x04\x06\x02\x01\x01\x12\x04\xca\x02\t\x17\n\r\n\x05\x04\x06\
    \x02\x01\x03\x12\x04\xca\x02\x1a\x1b\n\xcb\x02\n\x04\x04\x06\x02\x02\x12\
    \x04\xd1\x02\x02F\x1a\xbc\x02\x20Required.\x20The\x20row\x20keys\x20and\
    \x20corresponding\x20mutations\x20to\x20be\x20applied\x20in\x20bulk.\n\
    \x20Each\x20entry\x20is\x20applied\x20as\x20an\x20atomic\x20mutation,\
    \x20but\x20the\x20entries\x20may\x20be\n\x20applied\x20in\x20arbitrary\
    \x20order\x20(even\x20between\x20entries\x20for\x20the\x20same\x20row).\
    \n\x20At\x20least\x20one\x20entry\x20must\x20be\x20specified,\x20and\x20\
    in\x20total\x20the\x20entries\x20can\n\x20contain\x20at\x20most\x2010000\
    0\x20mutations.\n\n\r\n\x05\x04\x06\x02\x02\x04\x12\x04\xd1\x02\x02\n\n\
    \r\n\x05\x04\x06\x02\x02\x06\x12\x04\xd1\x02\x0b\x10\n\r\n\x05\x04\x06\
    \x02\x02\x01\x12\x04\xd1\x02\x11\x18\n\r\n\x05\x04\x06\x02\x02\x03\x12\
    \x04\xd1\x02\x1b\x1c\n\r\n\x05\x04\x06\x02\x02\x08\x12\x04\xd1\x02\x1dE\
    \n\x10\n\x08\x04\x06\x02\x02\x08\x9c\x08\0\x12\x04\xd1\x02\x1eD\n@\n\x02\
    \x04\x07\x12\x06\xd5\x02\0\xe5\x02\x01\x1a2\x20Response\x20message\x20fo\
    r\x20BigtableService.MutateRows.\n\n\x0b\n\x03\x04\x07\x01\x12\x04\xd5\
    \x02\x08\x1a\nS\n\x04\x04\x07\x03\0\x12\x06\xd7\x02\x02\xe1\x02\x03\x1aC\
    \x20The\x20result\x20of\x20applying\x20a\x20passed\x20mutation\x20in\x20\
    the\x20original\x20request.\n\n\r\n\x05\x04\x07\x03\0\x01\x12\x04\xd7\
    \x02\n\x0f\nz\n\x06\x04\x07\x03\0\x02\0\x12\x04\xda\x02\x04\x14\x1aj\x20\
    The\x20index\x20into\x20the\x20original\x20request's\x20`entries`\x20lis\
    t\x20of\x20the\x20Entry\n\x20for\x20which\x20a\x20result\x20is\x20being\
    \x20reported.\n\n\x0f\n\x07\x04\x07\x03\0\x02\0\x05\x12\x04\xda\x02\x04\
    \t\n\x0f\n\x07\x04\x07\x03\0\x02\0\x01\x12\x04\xda\x02\n\x0f\n\x0f\n\x07\
    \x04\x07\x03\0\x02\0\x03\x12\x04\xda\x02\x12\x13\n\x9e\x02\n\x06\x04\x07\
    \x03\0\x02\x01\x12\x04\xe0\x02\x04!\x1a\x8d\x02\x20The\x20result\x20of\
    \x20the\x20request\x20Entry\x20identified\x20by\x20`index`.\n\x20Dependi\
    ng\x20on\x20how\x20requests\x20are\x20batched\x20during\x20execution,\
    \x20it\x20is\x20possible\n\x20for\x20one\x20Entry\x20to\x20fail\x20due\
    \x20to\x20an\x20error\x20with\x20another\x20Entry.\x20In\x20the\x20event\
    \n\x20that\x20this\x20occurs,\x20the\x20same\x20error\x20will\x20be\x20r\
    eported\x20for\x20both\x20entries.\n\n\x0f\n\x07\x04\x07\x03\0\x02\x01\
    \x06\x12\x04\xe0\x02\x04\x15\n\x0f\n\x07\x04\x07\x03\0\x02\x01\x01\x12\
    \x04\xe0\x02\x16\x1c\n\x0f\n\x07\x04\x07\x03\0\x02\x01\x03\x12\x04\xe0\
    \x02\x1f\x20\nG\n\x04\x04\x07\x02\0\x12\x04\xe4\x02\x02\x1d\x1a9\x20One\
    \x20or\x20more\x20results\x20for\x20Entries\x20from\x20the\x20batch\x20r\
    equest.\n\n\r\n\x05\x04\x07\x02\0\x04\x12\x04\xe4\x02\x02\n\n\r\n\x05\
    \x04\x07\x02\0\x06\x12\x04\xe4\x02\x0b\x10\n\r\n\x05\x04\x07\x02\0\x01\
    \x12\x04\xe4\x02\x11\x18\n\r\n\x05\x04\x07\x02\0\x03\x12\x04\xe4\x02\x1b\
    \x1c\n?\n\x02\x04\x08\x12\x06\xe8\x02\0\x91\x03\x01\x1a1\x20Request\x20m\
    essage\x20for\x20Bigtable.CheckAndMutateRow.\n\n\x0b\n\x03\x04\x08\x01\
    \x12\x04\xe8\x02\x08\x20\n\xc2\x01\n\x04\x04\x08\x02\0\x12\x06\xed\x02\
    \x02\xf2\x02\x04\x1a\xb1\x01\x20Required.\x20The\x20unique\x20name\x20of\
    \x20the\x20table\x20to\x20which\x20the\x20conditional\x20mutation\x20sho\
    uld\x20be\n\x20applied.\n\x20Values\x20are\x20of\x20the\x20form\n\x20`pr\
    ojects/<project>/instances/<instance>/tables/<table>`.\n\n\r\n\x05\x04\
    \x08\x02\0\x05\x12\x04\xed\x02\x02\x08\n\r\n\x05\x04\x08\x02\0\x01\x12\
    \x04\xed\x02\t\x13\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\xed\x02\x16\x17\n\
    \x0f\n\x05\x04\x08\x02\0\x08\x12\x06\xed\x02\x18\xf2\x02\x03\n\x10\n\x08\
    \x04\x08\x02\0\x08\x9c\x08\0\x12\x04\xee\x02\x04*\n\x11\n\x07\x04\x08\
    \x02\0\x08\x9f\x08\x12\x06\xef\x02\x04\xf1\x02\x05\n\x80\x01\n\x04\x04\
    \x08\x02\x01\x12\x04\xf6\x02\x02\x1c\x1ar\x20This\x20value\x20specifies\
    \x20routing\x20for\x20replication.\x20If\x20not\x20specified,\x20the\n\
    \x20\"default\"\x20application\x20profile\x20will\x20be\x20used.\n\n\r\n\
    \x05\x04\x08\x02\x01\x05\x12\x04\xf6\x02\x02\x08\n\r\n\x05\x04\x08\x02\
    \x01\x01\x12\x04\xf6\x02\t\x17\n\r\n\x05\x04\x08\x02\x01\x03\x12\x04\xf6\
    \x02\x1a\x1b\n\xc0\x01\n\x04\x04\x08\x02\x02\x12\x04\xfc\x02\x02=\x1a\
    \xb1\x01\x20Required.\x20The\x20key\x20of\x20the\x20row\x20to\x20which\
    \x20the\x20conditional\x20mutation\x20should\x20be\x20applied.\n\n\x20Cl\
    assified\x20as\x20IDENTIFYING_ID\x20to\x20provide\x20context\x20around\
    \x20data\x20accesses\x20for\n\x20auditing\x20systems.\n\n\r\n\x05\x04\
    \x08\x02\x02\x05\x12\x04\xfc\x02\x02\x07\n\r\n\x05\x04\x08\x02\x02\x01\
    \x12\x04\xfc\x02\x08\x0f\n\r\n\x05\x04\x08\x02\x02\x03\x12\x04\xfc\x02\
    \x12\x13\n\r\n\x05\x04\x08\x02\x02\x08\x12\x04\xfc\x02\x14<\n\x10\n\x08\
    \x04\x08\x02\x02\x08\x9c\x08\0\x12\x04\xfc\x02\x15;\n\x80\x02\n\x04\x04\
    \x08\x02\x03\x12\x04\x82\x03\x02!\x1a\xf1\x01\x20The\x20filter\x20to\x20\
    be\x20applied\x20to\x20the\x20contents\x20of\x20the\x20specified\x20row.\
    \x20Depending\n\x20on\x20whether\x20or\x20not\x20any\x20results\x20are\
    \x20yielded,\x20either\x20`true_mutations`\x20or\n\x20`false_mutations`\
    \x20will\x20be\x20executed.\x20If\x20unset,\x20checks\x20that\x20the\x20\
    row\x20contains\n\x20any\x20values\x20at\x20all.\n\n\r\n\x05\x04\x08\x02\
    \x03\x06\x12\x04\x82\x03\x02\x0b\n\r\n\x05\x04\x08\x02\x03\x01\x12\x04\
    \x82\x03\x0c\x1c\n\r\n\x05\x04\x08\x02\x03\x03\x12\x04\x82\x03\x1f\x20\n\
    \xc1\x02\n\x04\x04\x08\x02\x04\x12\x04\x89\x03\x02'\x1a\xb2\x02\x20Chang\
    es\x20to\x20be\x20atomically\x20applied\x20to\x20the\x20specified\x20row\
    \x20if\x20`predicate_filter`\n\x20yields\x20at\x20least\x20one\x20cell\
    \x20when\x20applied\x20to\x20`row_key`.\x20Entries\x20are\x20applied\x20\
    in\n\x20order,\x20meaning\x20that\x20earlier\x20mutations\x20can\x20be\
    \x20masked\x20by\x20later\x20ones.\n\x20Must\x20contain\x20at\x20least\
    \x20one\x20entry\x20if\x20`false_mutations`\x20is\x20empty,\x20and\x20at\
    \x20most\n\x20100000.\n\n\r\n\x05\x04\x08\x02\x04\x04\x12\x04\x89\x03\
    \x02\n\n\r\n\x05\x04\x08\x02\x04\x06\x12\x04\x89\x03\x0b\x13\n\r\n\x05\
    \x04\x08\x02\x04\x01\x12\x04\x89\x03\x14\"\n\r\n\x05\x04\x08\x02\x04\x03\
    \x12\x04\x89\x03%&\n\xc0\x02\n\x04\x04\x08\x02\x05\x12\x04\x90\x03\x02(\
    \x1a\xb1\x02\x20Changes\x20to\x20be\x20atomically\x20applied\x20to\x20th\
    e\x20specified\x20row\x20if\x20`predicate_filter`\n\x20does\x20not\x20yi\
    eld\x20any\x20cells\x20when\x20applied\x20to\x20`row_key`.\x20Entries\
    \x20are\x20applied\x20in\n\x20order,\x20meaning\x20that\x20earlier\x20mu\
    tations\x20can\x20be\x20masked\x20by\x20later\x20ones.\n\x20Must\x20cont\
    ain\x20at\x20least\x20one\x20entry\x20if\x20`true_mutations`\x20is\x20em\
    pty,\x20and\x20at\x20most\n\x20100000.\n\n\r\n\x05\x04\x08\x02\x05\x04\
    \x12\x04\x90\x03\x02\n\n\r\n\x05\x04\x08\x02\x05\x06\x12\x04\x90\x03\x0b\
    \x13\n\r\n\x05\x04\x08\x02\x05\x01\x12\x04\x90\x03\x14#\n\r\n\x05\x04\
    \x08\x02\x05\x03\x12\x04\x90\x03&'\n@\n\x02\x04\t\x12\x06\x94\x03\0\x98\
    \x03\x01\x1a2\x20Response\x20message\x20for\x20Bigtable.CheckAndMutateRo\
    w.\n\n\x0b\n\x03\x04\t\x01\x12\x04\x94\x03\x08!\nk\n\x04\x04\t\x02\0\x12\
    \x04\x97\x03\x02\x1d\x1a]\x20Whether\x20or\x20not\x20the\x20request's\
    \x20`predicate_filter`\x20yielded\x20any\x20results\x20for\n\x20the\x20s\
    pecified\x20row.\n\n\r\n\x05\x04\t\x02\0\x05\x12\x04\x97\x03\x02\x06\n\r\
    \n\x05\x04\t\x02\0\x01\x12\x04\x97\x03\x07\x18\n\r\n\x05\x04\t\x02\0\x03\
    \x12\x04\x97\x03\x1b\x1c\n@\n\x02\x04\n\x12\x06\x9b\x03\0\xb5\x03\x01\
    \x1a2\x20Request\x20message\x20for\x20Bigtable.ReadModifyWriteRow.\n\n\
    \x0b\n\x03\x04\n\x01\x12\x04\x9b\x03\x08!\n\xc5\x01\n\x04\x04\n\x02\0\
    \x12\x06\xa0\x03\x02\xa5\x03\x04\x1a\xb4\x01\x20Required.\x20The\x20uniq\
    ue\x20name\x20of\x20the\x20table\x20to\x20which\x20the\x20read/modify/wr\
    ite\x20rules\x20should\x20be\n\x20applied.\n\x20Values\x20are\x20of\x20t\
    he\x20form\n\x20`projects/<project>/instances/<instance>/tables/<table>`\
    .\n\n\r\n\x05\x04\n\x02\0\x05\x12\x04\xa0\x03\x02\x08\n\r\n\x05\x04\n\
    \x02\0\x01\x12\x04\xa0\x03\t\x13\n\r\n\x05\x04\n\x02\0\x03\x12\x04\xa0\
    \x03\x16\x17\n\x0f\n\x05\x04\n\x02\0\x08\x12\x06\xa0\x03\x18\xa5\x03\x03\
    \n\x10\n\x08\x04\n\x02\0\x08\x9c\x08\0\x12\x04\xa1\x03\x04*\n\x11\n\x07\
    \x04\n\x02\0\x08\x9f\x08\x12\x06\xa2\x03\x04\xa4\x03\x05\n\x80\x01\n\x04\
    \x04\n\x02\x01\x12\x04\xa9\x03\x02\x1c\x1ar\x20This\x20value\x20specifie\
    s\x20routing\x20for\x20replication.\x20If\x20not\x20specified,\x20the\n\
    \x20\"default\"\x20application\x20profile\x20will\x20be\x20used.\n\n\r\n\
    \x05\x04\n\x02\x01\x05\x12\x04\xa9\x03\x02\x08\n\r\n\x05\x04\n\x02\x01\
    \x01\x12\x04\xa9\x03\t\x17\n\r\n\x05\x04\n\x02\x01\x03\x12\x04\xa9\x03\
    \x1a\x1b\n\xc3\x01\n\x04\x04\n\x02\x02\x12\x04\xaf\x03\x02=\x1a\xb4\x01\
    \x20Required.\x20The\x20key\x20of\x20the\x20row\x20to\x20which\x20the\
    \x20read/modify/write\x20rules\x20should\x20be\x20applied.\n\n\x20Classi\
    fied\x20as\x20IDENTIFYING_ID\x20to\x20provide\x20context\x20around\x20da\
    ta\x20accesses\x20for\n\x20auditing\x20systems.\n\n\r\n\x05\x04\n\x02\
    \x02\x05\x12\x04\xaf\x03\x02\x07\n\r\n\x05\x04\n\x02\x02\x01\x12\x04\xaf\
    \x03\x08\x0f\n\r\n\x05\x04\n\x02\x02\x03\x12\x04\xaf\x03\x12\x13\n\r\n\
    \x05\x04\n\x02\x02\x08\x12\x04\xaf\x03\x14<\n\x10\n\x08\x04\n\x02\x02\
    \x08\x9c\x08\0\x12\x04\xaf\x03\x15;\n\xd1\x01\n\x04\x04\n\x02\x03\x12\
    \x04\xb4\x03\x02R\x1a\xc2\x01\x20Required.\x20Rules\x20specifying\x20how\
    \x20the\x20specified\x20row's\x20contents\x20are\x20to\x20be\x20transfor\
    med\n\x20into\x20writes.\x20Entries\x20are\x20applied\x20in\x20order,\
    \x20meaning\x20that\x20earlier\x20rules\x20will\n\x20affect\x20the\x20re\
    sults\x20of\x20later\x20ones.\n\n\r\n\x05\x04\n\x02\x03\x04\x12\x04\xb4\
    \x03\x02\n\n\r\n\x05\x04\n\x02\x03\x06\x12\x04\xb4\x03\x0b\x1e\n\r\n\x05\
    \x04\n\x02\x03\x01\x12\x04\xb4\x03\x1f$\n\r\n\x05\x04\n\x02\x03\x03\x12\
    \x04\xb4\x03'(\n\r\n\x05\x04\n\x02\x03\x08\x12\x04\xb4\x03)Q\n\x10\n\x08\
    \x04\n\x02\x03\x08\x9c\x08\0\x12\x04\xb4\x03*P\nA\n\x02\x04\x0b\x12\x06\
    \xb8\x03\0\xbb\x03\x01\x1a3\x20Response\x20message\x20for\x20Bigtable.Re\
    adModifyWriteRow.\n\n\x0b\n\x03\x04\x0b\x01\x12\x04\xb8\x03\x08\"\nW\n\
    \x04\x04\x0b\x02\0\x12\x04\xba\x03\x02\x0e\x1aI\x20A\x20Row\x20containin\
    g\x20the\x20new\x20contents\x20of\x20all\x20cells\x20modified\x20by\x20t\
    he\x20request.\n\n\r\n\x05\x04\x0b\x02\0\x06\x12\x04\xba\x03\x02\x05\n\r\
    \n\x05\x04\x0b\x02\0\x01\x12\x04\xba\x03\x06\t\n\r\n\x05\x04\x0b\x02\0\
    \x03\x12\x04\xba\x03\x0c\rb\x06proto3\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}