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/admin/v2/bigtable_table_admin.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 CreateTableRequest {
    // message fields
    pub parent: ::std::string::String,
    pub table_id: ::std::string::String,
    pub table: ::protobuf::SingularPtrField<super::table::Table>,
    pub initial_splits: ::protobuf::RepeatedField<CreateTableRequest_Split>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string parent = 1;


    pub fn get_parent(&self) -> &str {
        &self.parent
    }
    pub fn clear_parent(&mut self) {
        self.parent.clear();
    }

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

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

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

    // string table_id = 2;


    pub fn get_table_id(&self) -> &str {
        &self.table_id
    }
    pub fn clear_table_id(&mut self) {
        self.table_id.clear();
    }

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

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

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

    // .google.bigtable.admin.v2.Table table = 3;


    pub fn get_table(&self) -> &super::table::Table {
        self.table.as_ref().unwrap_or_else(|| <super::table::Table as ::protobuf::Message>::default_instance())
    }
    pub fn clear_table(&mut self) {
        self.table.clear();
    }

    pub fn has_table(&self) -> bool {
        self.table.is_some()
    }

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

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

    // Take field
    pub fn take_table(&mut self) -> super::table::Table {
        self.table.take().unwrap_or_else(|| super::table::Table::new())
    }

    // repeated .google.bigtable.admin.v2.CreateTableRequest.Split initial_splits = 4;


    pub fn get_initial_splits(&self) -> &[CreateTableRequest_Split] {
        &self.initial_splits
    }
    pub fn clear_initial_splits(&mut self) {
        self.initial_splits.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_initial_splits(&mut self) -> &mut ::protobuf::RepeatedField<CreateTableRequest_Split> {
        &mut self.initial_splits
    }

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

impl ::protobuf::Message for CreateTableRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.table {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.initial_splits {
            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.parent)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_id)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.table)?;
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.initial_splits)?;
                },
                _ => {
                    ::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.parent.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.parent);
        }
        if !self.table_id.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.table_id);
        }
        if let Some(ref v) = self.table.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.initial_splits {
            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.parent.is_empty() {
            os.write_string(1, &self.parent)?;
        }
        if !self.table_id.is_empty() {
            os.write_string(2, &self.table_id)?;
        }
        if let Some(ref v) = self.table.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)?;
        }
        for v in &self.initial_splits {
            os.write_tag(4, ::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() -> CreateTableRequest {
        CreateTableRequest::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>(
                "parent",
                |m: &CreateTableRequest| { &m.parent },
                |m: &mut CreateTableRequest| { &mut m.parent },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "table_id",
                |m: &CreateTableRequest| { &m.table_id },
                |m: &mut CreateTableRequest| { &mut m.table_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::table::Table>>(
                "table",
                |m: &CreateTableRequest| { &m.table },
                |m: &mut CreateTableRequest| { &mut m.table },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CreateTableRequest_Split>>(
                "initial_splits",
                |m: &CreateTableRequest| { &m.initial_splits },
                |m: &mut CreateTableRequest| { &mut m.initial_splits },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CreateTableRequest>(
                "CreateTableRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CreateTableRequest {
    fn clear(&mut self) {
        self.parent.clear();
        self.table_id.clear();
        self.table.clear();
        self.initial_splits.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // bytes key = 1;


    pub fn get_key(&self) -> &[u8] {
        &self.key
    }
    pub fn clear_key(&mut self) {
        self.key.clear();
    }

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

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

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

impl ::protobuf::Message for CreateTableRequest_Split {
    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.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;
        if !self.key.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.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<()> {
        if !self.key.is_empty() {
            os.write_bytes(1, &self.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() -> CreateTableRequest_Split {
        CreateTableRequest_Split::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>(
                "key",
                |m: &CreateTableRequest_Split| { &m.key },
                |m: &mut CreateTableRequest_Split| { &mut m.key },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CreateTableRequest_Split>(
                "CreateTableRequest.Split",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CreateTableFromSnapshotRequest {
    // message fields
    pub parent: ::std::string::String,
    pub table_id: ::std::string::String,
    pub source_snapshot: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string parent = 1;


    pub fn get_parent(&self) -> &str {
        &self.parent
    }
    pub fn clear_parent(&mut self) {
        self.parent.clear();
    }

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

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

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

    // string table_id = 2;


    pub fn get_table_id(&self) -> &str {
        &self.table_id
    }
    pub fn clear_table_id(&mut self) {
        self.table_id.clear();
    }

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

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

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

    // string source_snapshot = 3;


    pub fn get_source_snapshot(&self) -> &str {
        &self.source_snapshot
    }
    pub fn clear_source_snapshot(&mut self) {
        self.source_snapshot.clear();
    }

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

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

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

impl ::protobuf::Message for CreateTableFromSnapshotRequest {
    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.parent)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table_id)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.source_snapshot)?;
                },
                _ => {
                    ::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.parent.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.parent);
        }
        if !self.table_id.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.table_id);
        }
        if !self.source_snapshot.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.source_snapshot);
        }
        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.parent.is_empty() {
            os.write_string(1, &self.parent)?;
        }
        if !self.table_id.is_empty() {
            os.write_string(2, &self.table_id)?;
        }
        if !self.source_snapshot.is_empty() {
            os.write_string(3, &self.source_snapshot)?;
        }
        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() -> CreateTableFromSnapshotRequest {
        CreateTableFromSnapshotRequest::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>(
                "parent",
                |m: &CreateTableFromSnapshotRequest| { &m.parent },
                |m: &mut CreateTableFromSnapshotRequest| { &mut m.parent },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "table_id",
                |m: &CreateTableFromSnapshotRequest| { &m.table_id },
                |m: &mut CreateTableFromSnapshotRequest| { &mut m.table_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "source_snapshot",
                |m: &CreateTableFromSnapshotRequest| { &m.source_snapshot },
                |m: &mut CreateTableFromSnapshotRequest| { &mut m.source_snapshot },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CreateTableFromSnapshotRequest>(
                "CreateTableFromSnapshotRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CreateTableFromSnapshotRequest {
    fn clear(&mut self) {
        self.parent.clear();
        self.table_id.clear();
        self.source_snapshot.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct DropRowRangeRequest {
    // message fields
    pub name: ::std::string::String,
    // message oneof groups
    pub target: ::std::option::Option<DropRowRangeRequest_oneof_target>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

#[derive(Clone,PartialEq,Debug)]
pub enum DropRowRangeRequest_oneof_target {
    row_key_prefix(::std::vec::Vec<u8>),
    delete_all_data_from_table(bool),
}

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

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

    // bytes row_key_prefix = 2;


    pub fn get_row_key_prefix(&self) -> &[u8] {
        match self.target {
            ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(ref v)) => v,
            _ => &[],
        }
    }
    pub fn clear_row_key_prefix(&mut self) {
        self.target = ::std::option::Option::None;
    }

    pub fn has_row_key_prefix(&self) -> bool {
        match self.target {
            ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_row_key_prefix(&mut self, v: ::std::vec::Vec<u8>) {
        self.target = ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(v))
    }

    // Mutable pointer to the field.
    pub fn mut_row_key_prefix(&mut self) -> &mut ::std::vec::Vec<u8> {
        if let ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(_)) = self.target {
        } else {
            self.target = ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(::std::vec::Vec::new()));
        }
        match self.target {
            ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_row_key_prefix(&mut self) -> ::std::vec::Vec<u8> {
        if self.has_row_key_prefix() {
            match self.target.take() {
                ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::vec::Vec::new()
        }
    }

    // bool delete_all_data_from_table = 3;


    pub fn get_delete_all_data_from_table(&self) -> bool {
        match self.target {
            ::std::option::Option::Some(DropRowRangeRequest_oneof_target::delete_all_data_from_table(v)) => v,
            _ => false,
        }
    }
    pub fn clear_delete_all_data_from_table(&mut self) {
        self.target = ::std::option::Option::None;
    }

    pub fn has_delete_all_data_from_table(&self) -> bool {
        match self.target {
            ::std::option::Option::Some(DropRowRangeRequest_oneof_target::delete_all_data_from_table(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_delete_all_data_from_table(&mut self, v: bool) {
        self.target = ::std::option::Option::Some(DropRowRangeRequest_oneof_target::delete_all_data_from_table(v))
    }
}

impl ::protobuf::Message for DropRowRangeRequest {
    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.name)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.target = ::std::option::Option::Some(DropRowRangeRequest_oneof_target::row_key_prefix(is.read_bytes()?));
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.target = ::std::option::Option::Some(DropRowRangeRequest_oneof_target::delete_all_data_from_table(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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if let ::std::option::Option::Some(ref v) = self.target {
            match v {
                &DropRowRangeRequest_oneof_target::row_key_prefix(ref v) => {
                    my_size += ::protobuf::rt::bytes_size(2, &v);
                },
                &DropRowRangeRequest_oneof_target::delete_all_data_from_table(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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if let ::std::option::Option::Some(ref v) = self.target {
            match v {
                &DropRowRangeRequest_oneof_target::row_key_prefix(ref v) => {
                    os.write_bytes(2, v)?;
                },
                &DropRowRangeRequest_oneof_target::delete_all_data_from_table(v) => {
                    os.write_bool(3, 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() -> DropRowRangeRequest {
        DropRowRangeRequest::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>(
                "name",
                |m: &DropRowRangeRequest| { &m.name },
                |m: &mut DropRowRangeRequest| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>(
                "row_key_prefix",
                DropRowRangeRequest::has_row_key_prefix,
                DropRowRangeRequest::get_row_key_prefix,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>(
                "delete_all_data_from_table",
                DropRowRangeRequest::has_delete_all_data_from_table,
                DropRowRangeRequest::get_delete_all_data_from_table,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DropRowRangeRequest>(
                "DropRowRangeRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for DropRowRangeRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.target = ::std::option::Option::None;
        self.target = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListTablesRequest {
    // message fields
    pub parent: ::std::string::String,
    pub view: super::table::Table_View,
    pub page_size: i32,
    pub page_token: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string parent = 1;


    pub fn get_parent(&self) -> &str {
        &self.parent
    }
    pub fn clear_parent(&mut self) {
        self.parent.clear();
    }

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

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

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

    // .google.bigtable.admin.v2.Table.View view = 2;


    pub fn get_view(&self) -> super::table::Table_View {
        self.view
    }
    pub fn clear_view(&mut self) {
        self.view = super::table::Table_View::VIEW_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_view(&mut self, v: super::table::Table_View) {
        self.view = v;
    }

    // int32 page_size = 4;


    pub fn get_page_size(&self) -> i32 {
        self.page_size
    }
    pub fn clear_page_size(&mut self) {
        self.page_size = 0;
    }

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

    // string page_token = 3;


    pub fn get_page_token(&self) -> &str {
        &self.page_token
    }
    pub fn clear_page_token(&mut self) {
        self.page_token.clear();
    }

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

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

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

impl ::protobuf::Message for ListTablesRequest {
    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.parent)?;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.view, 2, &mut self.unknown_fields)?
                },
                4 => {
                    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.page_size = tmp;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?;
                },
                _ => {
                    ::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.parent.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.parent);
        }
        if self.view != super::table::Table_View::VIEW_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.view);
        }
        if self.page_size != 0 {
            my_size += ::protobuf::rt::value_size(4, self.page_size, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.page_token);
        }
        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.parent.is_empty() {
            os.write_string(1, &self.parent)?;
        }
        if self.view != super::table::Table_View::VIEW_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.view))?;
        }
        if self.page_size != 0 {
            os.write_int32(4, self.page_size)?;
        }
        if !self.page_token.is_empty() {
            os.write_string(3, &self.page_token)?;
        }
        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() -> ListTablesRequest {
        ListTablesRequest::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>(
                "parent",
                |m: &ListTablesRequest| { &m.parent },
                |m: &mut ListTablesRequest| { &mut m.parent },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::table::Table_View>>(
                "view",
                |m: &ListTablesRequest| { &m.view },
                |m: &mut ListTablesRequest| { &mut m.view },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "page_size",
                |m: &ListTablesRequest| { &m.page_size },
                |m: &mut ListTablesRequest| { &mut m.page_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "page_token",
                |m: &ListTablesRequest| { &m.page_token },
                |m: &mut ListTablesRequest| { &mut m.page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListTablesRequest>(
                "ListTablesRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ListTablesRequest {
    fn clear(&mut self) {
        self.parent.clear();
        self.view = super::table::Table_View::VIEW_UNSPECIFIED;
        self.page_size = 0;
        self.page_token.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListTablesResponse {
    // message fields
    pub tables: ::protobuf::RepeatedField<super::table::Table>,
    pub next_page_token: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .google.bigtable.admin.v2.Table tables = 1;


    pub fn get_tables(&self) -> &[super::table::Table] {
        &self.tables
    }
    pub fn clear_tables(&mut self) {
        self.tables.clear();
    }

    // Param is passed by value, moved
    pub fn set_tables(&mut self, v: ::protobuf::RepeatedField<super::table::Table>) {
        self.tables = v;
    }

    // Mutable pointer to the field.
    pub fn mut_tables(&mut self) -> &mut ::protobuf::RepeatedField<super::table::Table> {
        &mut self.tables
    }

    // Take field
    pub fn take_tables(&mut self) -> ::protobuf::RepeatedField<super::table::Table> {
        ::std::mem::replace(&mut self.tables, ::protobuf::RepeatedField::new())
    }

    // string next_page_token = 2;


    pub fn get_next_page_token(&self) -> &str {
        &self.next_page_token
    }
    pub fn clear_next_page_token(&mut self) {
        self.next_page_token.clear();
    }

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

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

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

impl ::protobuf::Message for ListTablesResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.tables {
            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.tables)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?;
                },
                _ => {
                    ::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.tables {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if !self.next_page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.next_page_token);
        }
        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.tables {
            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.next_page_token.is_empty() {
            os.write_string(2, &self.next_page_token)?;
        }
        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() -> ListTablesResponse {
        ListTablesResponse::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<super::table::Table>>(
                "tables",
                |m: &ListTablesResponse| { &m.tables },
                |m: &mut ListTablesResponse| { &mut m.tables },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "next_page_token",
                |m: &ListTablesResponse| { &m.next_page_token },
                |m: &mut ListTablesResponse| { &mut m.next_page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListTablesResponse>(
                "ListTablesResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct GetTableRequest {
    // message fields
    pub name: ::std::string::String,
    pub view: super::table::Table_View,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

    // .google.bigtable.admin.v2.Table.View view = 2;


    pub fn get_view(&self) -> super::table::Table_View {
        self.view
    }
    pub fn clear_view(&mut self) {
        self.view = super::table::Table_View::VIEW_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_view(&mut self, v: super::table::Table_View) {
        self.view = v;
    }
}

impl ::protobuf::Message for GetTableRequest {
    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.name)?;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.view, 2, &mut self.unknown_fields)?
                },
                _ => {
                    ::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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if self.view != super::table::Table_View::VIEW_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.view);
        }
        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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if self.view != super::table::Table_View::VIEW_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.view))?;
        }
        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() -> GetTableRequest {
        GetTableRequest::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>(
                "name",
                |m: &GetTableRequest| { &m.name },
                |m: &mut GetTableRequest| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::table::Table_View>>(
                "view",
                |m: &GetTableRequest| { &m.view },
                |m: &mut GetTableRequest| { &mut m.view },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetTableRequest>(
                "GetTableRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for GetTableRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.view = super::table::Table_View::VIEW_UNSPECIFIED;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

impl ::protobuf::Message for DeleteTableRequest {
    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.name)?;
                },
                _ => {
                    ::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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        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() -> DeleteTableRequest {
        DeleteTableRequest::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>(
                "name",
                |m: &DeleteTableRequest| { &m.name },
                |m: &mut DeleteTableRequest| { &mut m.name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DeleteTableRequest>(
                "DeleteTableRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ModifyColumnFamiliesRequest {
    // message fields
    pub name: ::std::string::String,
    pub modifications: ::protobuf::RepeatedField<ModifyColumnFamiliesRequest_Modification>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

    // repeated .google.bigtable.admin.v2.ModifyColumnFamiliesRequest.Modification modifications = 2;


    pub fn get_modifications(&self) -> &[ModifyColumnFamiliesRequest_Modification] {
        &self.modifications
    }
    pub fn clear_modifications(&mut self) {
        self.modifications.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_modifications(&mut self) -> &mut ::protobuf::RepeatedField<ModifyColumnFamiliesRequest_Modification> {
        &mut self.modifications
    }

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

impl ::protobuf::Message for ModifyColumnFamiliesRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.modifications {
            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.name)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.modifications)?;
                },
                _ => {
                    ::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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        for value in &self.modifications {
            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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        for v in &self.modifications {
            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() -> ModifyColumnFamiliesRequest {
        ModifyColumnFamiliesRequest::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>(
                "name",
                |m: &ModifyColumnFamiliesRequest| { &m.name },
                |m: &mut ModifyColumnFamiliesRequest| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ModifyColumnFamiliesRequest_Modification>>(
                "modifications",
                |m: &ModifyColumnFamiliesRequest| { &m.modifications },
                |m: &mut ModifyColumnFamiliesRequest| { &mut m.modifications },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ModifyColumnFamiliesRequest>(
                "ModifyColumnFamiliesRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ModifyColumnFamiliesRequest_Modification {
    // message fields
    pub id: ::std::string::String,
    // message oneof groups
    pub field_mod: ::std::option::Option<ModifyColumnFamiliesRequest_Modification_oneof_mod>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

#[derive(Clone,PartialEq,Debug)]
pub enum ModifyColumnFamiliesRequest_Modification_oneof_mod {
    create(super::table::ColumnFamily),
    update(super::table::ColumnFamily),
    drop(bool),
}

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

    // string id = 1;


    pub fn get_id(&self) -> &str {
        &self.id
    }
    pub fn clear_id(&mut self) {
        self.id.clear();
    }

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

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

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

    // .google.bigtable.admin.v2.ColumnFamily create = 2;


    pub fn get_create(&self) -> &super::table::ColumnFamily {
        match self.field_mod {
            ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(ref v)) => v,
            _ => <super::table::ColumnFamily as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_create(&mut self) {
        self.field_mod = ::std::option::Option::None;
    }

    pub fn has_create(&self) -> bool {
        match self.field_mod {
            ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_create(&mut self, v: super::table::ColumnFamily) {
        self.field_mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(v))
    }

    // Mutable pointer to the field.
    pub fn mut_create(&mut self) -> &mut super::table::ColumnFamily {
        if let ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(_)) = self.field_mod {
        } else {
            self.field_mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(super::table::ColumnFamily::new()));
        }
        match self.field_mod {
            ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_create(&mut self) -> super::table::ColumnFamily {
        if self.has_create() {
            match self.field_mod.take() {
                ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(v)) => v,
                _ => panic!(),
            }
        } else {
            super::table::ColumnFamily::new()
        }
    }

    // .google.bigtable.admin.v2.ColumnFamily update = 3;


    pub fn get_update(&self) -> &super::table::ColumnFamily {
        match self.field_mod {
            ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(ref v)) => v,
            _ => <super::table::ColumnFamily as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_update(&mut self) {
        self.field_mod = ::std::option::Option::None;
    }

    pub fn has_update(&self) -> bool {
        match self.field_mod {
            ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_update(&mut self, v: super::table::ColumnFamily) {
        self.field_mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(v))
    }

    // Mutable pointer to the field.
    pub fn mut_update(&mut self) -> &mut super::table::ColumnFamily {
        if let ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(_)) = self.field_mod {
        } else {
            self.field_mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(super::table::ColumnFamily::new()));
        }
        match self.field_mod {
            ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_update(&mut self) -> super::table::ColumnFamily {
        if self.has_update() {
            match self.field_mod.take() {
                ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(v)) => v,
                _ => panic!(),
            }
        } else {
            super::table::ColumnFamily::new()
        }
    }

    // bool drop = 4;


    pub fn get_drop(&self) -> bool {
        match self.field_mod {
            ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::drop(v)) => v,
            _ => false,
        }
    }
    pub fn clear_drop(&mut self) {
        self.field_mod = ::std::option::Option::None;
    }

    pub fn has_drop(&self) -> bool {
        match self.field_mod {
            ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::drop(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_drop(&mut self, v: bool) {
        self.field_mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::drop(v))
    }
}

impl ::protobuf::Message for ModifyColumnFamiliesRequest_Modification {
    fn is_initialized(&self) -> bool {
        if let Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(ref v)) = self.field_mod {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(ref v)) = self.field_mod {
            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.id)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.field_mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::create(is.read_message()?));
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.field_mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::update(is.read_message()?));
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.field_mod = ::std::option::Option::Some(ModifyColumnFamiliesRequest_Modification_oneof_mod::drop(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.id.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.id);
        }
        if let ::std::option::Option::Some(ref v) = self.field_mod {
            match v {
                &ModifyColumnFamiliesRequest_Modification_oneof_mod::create(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &ModifyColumnFamiliesRequest_Modification_oneof_mod::update(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &ModifyColumnFamiliesRequest_Modification_oneof_mod::drop(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.id.is_empty() {
            os.write_string(1, &self.id)?;
        }
        if let ::std::option::Option::Some(ref v) = self.field_mod {
            match v {
                &ModifyColumnFamiliesRequest_Modification_oneof_mod::create(ref v) => {
                    os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &ModifyColumnFamiliesRequest_Modification_oneof_mod::update(ref v) => {
                    os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &ModifyColumnFamiliesRequest_Modification_oneof_mod::drop(v) => {
                    os.write_bool(4, 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() -> ModifyColumnFamiliesRequest_Modification {
        ModifyColumnFamiliesRequest_Modification::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>(
                "id",
                |m: &ModifyColumnFamiliesRequest_Modification| { &m.id },
                |m: &mut ModifyColumnFamiliesRequest_Modification| { &mut m.id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::table::ColumnFamily>(
                "create",
                ModifyColumnFamiliesRequest_Modification::has_create,
                ModifyColumnFamiliesRequest_Modification::get_create,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::table::ColumnFamily>(
                "update",
                ModifyColumnFamiliesRequest_Modification::has_update,
                ModifyColumnFamiliesRequest_Modification::get_update,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>(
                "drop",
                ModifyColumnFamiliesRequest_Modification::has_drop,
                ModifyColumnFamiliesRequest_Modification::get_drop,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ModifyColumnFamiliesRequest_Modification>(
                "ModifyColumnFamiliesRequest.Modification",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ModifyColumnFamiliesRequest_Modification {
    fn clear(&mut self) {
        self.id.clear();
        self.field_mod = ::std::option::Option::None;
        self.field_mod = ::std::option::Option::None;
        self.field_mod = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

impl ::protobuf::Message for GenerateConsistencyTokenRequest {
    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.name)?;
                },
                _ => {
                    ::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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        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() -> GenerateConsistencyTokenRequest {
        GenerateConsistencyTokenRequest::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>(
                "name",
                |m: &GenerateConsistencyTokenRequest| { &m.name },
                |m: &mut GenerateConsistencyTokenRequest| { &mut m.name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GenerateConsistencyTokenRequest>(
                "GenerateConsistencyTokenRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // string consistency_token = 1;


    pub fn get_consistency_token(&self) -> &str {
        &self.consistency_token
    }
    pub fn clear_consistency_token(&mut self) {
        self.consistency_token.clear();
    }

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

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

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

impl ::protobuf::Message for GenerateConsistencyTokenResponse {
    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.consistency_token)?;
                },
                _ => {
                    ::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.consistency_token.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.consistency_token);
        }
        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.consistency_token.is_empty() {
            os.write_string(1, &self.consistency_token)?;
        }
        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() -> GenerateConsistencyTokenResponse {
        GenerateConsistencyTokenResponse::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>(
                "consistency_token",
                |m: &GenerateConsistencyTokenResponse| { &m.consistency_token },
                |m: &mut GenerateConsistencyTokenResponse| { &mut m.consistency_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GenerateConsistencyTokenResponse>(
                "GenerateConsistencyTokenResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

    // string consistency_token = 2;


    pub fn get_consistency_token(&self) -> &str {
        &self.consistency_token
    }
    pub fn clear_consistency_token(&mut self) {
        self.consistency_token.clear();
    }

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

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

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

impl ::protobuf::Message for CheckConsistencyRequest {
    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.name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.consistency_token)?;
                },
                _ => {
                    ::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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if !self.consistency_token.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.consistency_token);
        }
        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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if !self.consistency_token.is_empty() {
            os.write_string(2, &self.consistency_token)?;
        }
        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() -> CheckConsistencyRequest {
        CheckConsistencyRequest::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>(
                "name",
                |m: &CheckConsistencyRequest| { &m.name },
                |m: &mut CheckConsistencyRequest| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "consistency_token",
                |m: &CheckConsistencyRequest| { &m.consistency_token },
                |m: &mut CheckConsistencyRequest| { &mut m.consistency_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CheckConsistencyRequest>(
                "CheckConsistencyRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // bool consistent = 1;


    pub fn get_consistent(&self) -> bool {
        self.consistent
    }
    pub fn clear_consistent(&mut self) {
        self.consistent = false;
    }

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

impl ::protobuf::Message for CheckConsistencyResponse {
    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.consistent = 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.consistent != 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.consistent != false {
            os.write_bool(1, self.consistent)?;
        }
        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() -> CheckConsistencyResponse {
        CheckConsistencyResponse::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>(
                "consistent",
                |m: &CheckConsistencyResponse| { &m.consistent },
                |m: &mut CheckConsistencyResponse| { &mut m.consistent },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CheckConsistencyResponse>(
                "CheckConsistencyResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct SnapshotTableRequest {
    // message fields
    pub name: ::std::string::String,
    pub cluster: ::std::string::String,
    pub snapshot_id: ::std::string::String,
    pub ttl: ::protobuf::SingularPtrField<::protobuf::well_known_types::Duration>,
    pub description: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

    // string cluster = 2;


    pub fn get_cluster(&self) -> &str {
        &self.cluster
    }
    pub fn clear_cluster(&mut self) {
        self.cluster.clear();
    }

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

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

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

    // string snapshot_id = 3;


    pub fn get_snapshot_id(&self) -> &str {
        &self.snapshot_id
    }
    pub fn clear_snapshot_id(&mut self) {
        self.snapshot_id.clear();
    }

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

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

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

    // .google.protobuf.Duration ttl = 4;


    pub fn get_ttl(&self) -> &::protobuf::well_known_types::Duration {
        self.ttl.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Duration as ::protobuf::Message>::default_instance())
    }
    pub fn clear_ttl(&mut self) {
        self.ttl.clear();
    }

    pub fn has_ttl(&self) -> bool {
        self.ttl.is_some()
    }

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

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

    // Take field
    pub fn take_ttl(&mut self) -> ::protobuf::well_known_types::Duration {
        self.ttl.take().unwrap_or_else(|| ::protobuf::well_known_types::Duration::new())
    }

    // string description = 5;


    pub fn get_description(&self) -> &str {
        &self.description
    }
    pub fn clear_description(&mut self) {
        self.description.clear();
    }

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

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

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

impl ::protobuf::Message for SnapshotTableRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.ttl {
            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.name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cluster)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.snapshot_id)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.ttl)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.description)?;
                },
                _ => {
                    ::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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if !self.cluster.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.cluster);
        }
        if !self.snapshot_id.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.snapshot_id);
        }
        if let Some(ref v) = self.ttl.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.description.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.description);
        }
        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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if !self.cluster.is_empty() {
            os.write_string(2, &self.cluster)?;
        }
        if !self.snapshot_id.is_empty() {
            os.write_string(3, &self.snapshot_id)?;
        }
        if let Some(ref v) = self.ttl.as_ref() {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if !self.description.is_empty() {
            os.write_string(5, &self.description)?;
        }
        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() -> SnapshotTableRequest {
        SnapshotTableRequest::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>(
                "name",
                |m: &SnapshotTableRequest| { &m.name },
                |m: &mut SnapshotTableRequest| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "cluster",
                |m: &SnapshotTableRequest| { &m.cluster },
                |m: &mut SnapshotTableRequest| { &mut m.cluster },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "snapshot_id",
                |m: &SnapshotTableRequest| { &m.snapshot_id },
                |m: &mut SnapshotTableRequest| { &mut m.snapshot_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Duration>>(
                "ttl",
                |m: &SnapshotTableRequest| { &m.ttl },
                |m: &mut SnapshotTableRequest| { &mut m.ttl },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "description",
                |m: &SnapshotTableRequest| { &m.description },
                |m: &mut SnapshotTableRequest| { &mut m.description },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SnapshotTableRequest>(
                "SnapshotTableRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for SnapshotTableRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.cluster.clear();
        self.snapshot_id.clear();
        self.ttl.clear();
        self.description.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

impl ::protobuf::Message for GetSnapshotRequest {
    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.name)?;
                },
                _ => {
                    ::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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        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() -> GetSnapshotRequest {
        GetSnapshotRequest::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>(
                "name",
                |m: &GetSnapshotRequest| { &m.name },
                |m: &mut GetSnapshotRequest| { &mut m.name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetSnapshotRequest>(
                "GetSnapshotRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListSnapshotsRequest {
    // message fields
    pub parent: ::std::string::String,
    pub page_size: i32,
    pub page_token: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string parent = 1;


    pub fn get_parent(&self) -> &str {
        &self.parent
    }
    pub fn clear_parent(&mut self) {
        self.parent.clear();
    }

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

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

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

    // int32 page_size = 2;


    pub fn get_page_size(&self) -> i32 {
        self.page_size
    }
    pub fn clear_page_size(&mut self) {
        self.page_size = 0;
    }

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

    // string page_token = 3;


    pub fn get_page_token(&self) -> &str {
        &self.page_token
    }
    pub fn clear_page_token(&mut self) {
        self.page_token.clear();
    }

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

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

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

impl ::protobuf::Message for ListSnapshotsRequest {
    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.parent)?;
                },
                2 => {
                    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.page_size = tmp;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?;
                },
                _ => {
                    ::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.parent.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.parent);
        }
        if self.page_size != 0 {
            my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.page_token);
        }
        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.parent.is_empty() {
            os.write_string(1, &self.parent)?;
        }
        if self.page_size != 0 {
            os.write_int32(2, self.page_size)?;
        }
        if !self.page_token.is_empty() {
            os.write_string(3, &self.page_token)?;
        }
        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() -> ListSnapshotsRequest {
        ListSnapshotsRequest::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>(
                "parent",
                |m: &ListSnapshotsRequest| { &m.parent },
                |m: &mut ListSnapshotsRequest| { &mut m.parent },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "page_size",
                |m: &ListSnapshotsRequest| { &m.page_size },
                |m: &mut ListSnapshotsRequest| { &mut m.page_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "page_token",
                |m: &ListSnapshotsRequest| { &m.page_token },
                |m: &mut ListSnapshotsRequest| { &mut m.page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListSnapshotsRequest>(
                "ListSnapshotsRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ListSnapshotsRequest {
    fn clear(&mut self) {
        self.parent.clear();
        self.page_size = 0;
        self.page_token.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ListSnapshotsResponse {
    // message fields
    pub snapshots: ::protobuf::RepeatedField<super::table::Snapshot>,
    pub next_page_token: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .google.bigtable.admin.v2.Snapshot snapshots = 1;


    pub fn get_snapshots(&self) -> &[super::table::Snapshot] {
        &self.snapshots
    }
    pub fn clear_snapshots(&mut self) {
        self.snapshots.clear();
    }

    // Param is passed by value, moved
    pub fn set_snapshots(&mut self, v: ::protobuf::RepeatedField<super::table::Snapshot>) {
        self.snapshots = v;
    }

    // Mutable pointer to the field.
    pub fn mut_snapshots(&mut self) -> &mut ::protobuf::RepeatedField<super::table::Snapshot> {
        &mut self.snapshots
    }

    // Take field
    pub fn take_snapshots(&mut self) -> ::protobuf::RepeatedField<super::table::Snapshot> {
        ::std::mem::replace(&mut self.snapshots, ::protobuf::RepeatedField::new())
    }

    // string next_page_token = 2;


    pub fn get_next_page_token(&self) -> &str {
        &self.next_page_token
    }
    pub fn clear_next_page_token(&mut self) {
        self.next_page_token.clear();
    }

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

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

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

impl ::protobuf::Message for ListSnapshotsResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.snapshots {
            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.snapshots)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?;
                },
                _ => {
                    ::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.snapshots {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if !self.next_page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.next_page_token);
        }
        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.snapshots {
            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.next_page_token.is_empty() {
            os.write_string(2, &self.next_page_token)?;
        }
        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() -> ListSnapshotsResponse {
        ListSnapshotsResponse::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<super::table::Snapshot>>(
                "snapshots",
                |m: &ListSnapshotsResponse| { &m.snapshots },
                |m: &mut ListSnapshotsResponse| { &mut m.snapshots },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "next_page_token",
                |m: &ListSnapshotsResponse| { &m.next_page_token },
                |m: &mut ListSnapshotsResponse| { &mut m.next_page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListSnapshotsResponse>(
                "ListSnapshotsResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

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

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

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

impl ::protobuf::Message for DeleteSnapshotRequest {
    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.name)?;
                },
                _ => {
                    ::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.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        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.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        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() -> DeleteSnapshotRequest {
        DeleteSnapshotRequest::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>(
                "name",
                |m: &DeleteSnapshotRequest| { &m.name },
                |m: &mut DeleteSnapshotRequest| { &mut m.name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DeleteSnapshotRequest>(
                "DeleteSnapshotRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct SnapshotTableMetadata {
    // message fields
    pub original_request: ::protobuf::SingularPtrField<SnapshotTableRequest>,
    pub request_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    pub finish_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .google.bigtable.admin.v2.SnapshotTableRequest original_request = 1;


    pub fn get_original_request(&self) -> &SnapshotTableRequest {
        self.original_request.as_ref().unwrap_or_else(|| <SnapshotTableRequest as ::protobuf::Message>::default_instance())
    }
    pub fn clear_original_request(&mut self) {
        self.original_request.clear();
    }

    pub fn has_original_request(&self) -> bool {
        self.original_request.is_some()
    }

    // Param is passed by value, moved
    pub fn set_original_request(&mut self, v: SnapshotTableRequest) {
        self.original_request = ::protobuf::SingularPtrField::some(v);
    }

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

    // Take field
    pub fn take_original_request(&mut self) -> SnapshotTableRequest {
        self.original_request.take().unwrap_or_else(|| SnapshotTableRequest::new())
    }

    // .google.protobuf.Timestamp request_time = 2;


    pub fn get_request_time(&self) -> &::protobuf::well_known_types::Timestamp {
        self.request_time.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
    }
    pub fn clear_request_time(&mut self) {
        self.request_time.clear();
    }

    pub fn has_request_time(&self) -> bool {
        self.request_time.is_some()
    }

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

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

    // Take field
    pub fn take_request_time(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.request_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }

    // .google.protobuf.Timestamp finish_time = 3;


    pub fn get_finish_time(&self) -> &::protobuf::well_known_types::Timestamp {
        self.finish_time.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
    }
    pub fn clear_finish_time(&mut self) {
        self.finish_time.clear();
    }

    pub fn has_finish_time(&self) -> bool {
        self.finish_time.is_some()
    }

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

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

    // Take field
    pub fn take_finish_time(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.finish_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }
}

impl ::protobuf::Message for SnapshotTableMetadata {
    fn is_initialized(&self) -> bool {
        for v in &self.original_request {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.request_time {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.finish_time {
            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.original_request)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.request_time)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.finish_time)?;
                },
                _ => {
                    ::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.original_request.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.request_time.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.finish_time.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.original_request.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)?;
        }
        if let Some(ref v) = self.request_time.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.finish_time.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)?;
        }
        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() -> SnapshotTableMetadata {
        SnapshotTableMetadata::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<SnapshotTableRequest>>(
                "original_request",
                |m: &SnapshotTableMetadata| { &m.original_request },
                |m: &mut SnapshotTableMetadata| { &mut m.original_request },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                "request_time",
                |m: &SnapshotTableMetadata| { &m.request_time },
                |m: &mut SnapshotTableMetadata| { &mut m.request_time },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                "finish_time",
                |m: &SnapshotTableMetadata| { &m.finish_time },
                |m: &mut SnapshotTableMetadata| { &mut m.finish_time },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SnapshotTableMetadata>(
                "SnapshotTableMetadata",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for SnapshotTableMetadata {
    fn clear(&mut self) {
        self.original_request.clear();
        self.request_time.clear();
        self.finish_time.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CreateTableFromSnapshotMetadata {
    // message fields
    pub original_request: ::protobuf::SingularPtrField<CreateTableFromSnapshotRequest>,
    pub request_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    pub finish_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .google.bigtable.admin.v2.CreateTableFromSnapshotRequest original_request = 1;


    pub fn get_original_request(&self) -> &CreateTableFromSnapshotRequest {
        self.original_request.as_ref().unwrap_or_else(|| <CreateTableFromSnapshotRequest as ::protobuf::Message>::default_instance())
    }
    pub fn clear_original_request(&mut self) {
        self.original_request.clear();
    }

    pub fn has_original_request(&self) -> bool {
        self.original_request.is_some()
    }

    // Param is passed by value, moved
    pub fn set_original_request(&mut self, v: CreateTableFromSnapshotRequest) {
        self.original_request = ::protobuf::SingularPtrField::some(v);
    }

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

    // Take field
    pub fn take_original_request(&mut self) -> CreateTableFromSnapshotRequest {
        self.original_request.take().unwrap_or_else(|| CreateTableFromSnapshotRequest::new())
    }

    // .google.protobuf.Timestamp request_time = 2;


    pub fn get_request_time(&self) -> &::protobuf::well_known_types::Timestamp {
        self.request_time.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
    }
    pub fn clear_request_time(&mut self) {
        self.request_time.clear();
    }

    pub fn has_request_time(&self) -> bool {
        self.request_time.is_some()
    }

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

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

    // Take field
    pub fn take_request_time(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.request_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }

    // .google.protobuf.Timestamp finish_time = 3;


    pub fn get_finish_time(&self) -> &::protobuf::well_known_types::Timestamp {
        self.finish_time.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
    }
    pub fn clear_finish_time(&mut self) {
        self.finish_time.clear();
    }

    pub fn has_finish_time(&self) -> bool {
        self.finish_time.is_some()
    }

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

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

    // Take field
    pub fn take_finish_time(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.finish_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }
}

impl ::protobuf::Message for CreateTableFromSnapshotMetadata {
    fn is_initialized(&self) -> bool {
        for v in &self.original_request {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.request_time {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.finish_time {
            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.original_request)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.request_time)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.finish_time)?;
                },
                _ => {
                    ::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.original_request.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.request_time.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.finish_time.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.original_request.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)?;
        }
        if let Some(ref v) = self.request_time.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.finish_time.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)?;
        }
        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() -> CreateTableFromSnapshotMetadata {
        CreateTableFromSnapshotMetadata::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<CreateTableFromSnapshotRequest>>(
                "original_request",
                |m: &CreateTableFromSnapshotMetadata| { &m.original_request },
                |m: &mut CreateTableFromSnapshotMetadata| { &mut m.original_request },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                "request_time",
                |m: &CreateTableFromSnapshotMetadata| { &m.request_time },
                |m: &mut CreateTableFromSnapshotMetadata| { &mut m.request_time },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                "finish_time",
                |m: &CreateTableFromSnapshotMetadata| { &m.finish_time },
                |m: &mut CreateTableFromSnapshotMetadata| { &mut m.finish_time },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CreateTableFromSnapshotMetadata>(
                "CreateTableFromSnapshotMetadata",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CreateTableFromSnapshotMetadata {
    fn clear(&mut self) {
        self.original_request.clear();
        self.request_time.clear();
        self.finish_time.clear();
        self.unknown_fields.clear();
    }
}

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n3google/bigtable/admin/v2/bigtable_table_admin.proto\x12\x18google.big\
    table.admin.v2\x1a\x1cgoogle/api/annotations.proto\x1a$google/bigtable/a\
    dmin/v2/table.proto\x1a\x1egoogle/iam/v1/iam_policy.proto\x1a\x1agoogle/\
    iam/v1/policy.proto\x1a#google/longrunning/operations.proto\x1a\x1egoogl\
    e/protobuf/duration.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoog\
    le/protobuf/timestamp.proto\"\xf4\x01\n\x12CreateTableRequest\x12\x16\n\
    \x06parent\x18\x01\x20\x01(\tR\x06parent\x12\x19\n\x08table_id\x18\x02\
    \x20\x01(\tR\x07tableId\x125\n\x05table\x18\x03\x20\x01(\x0b2\x1f.google\
    .bigtable.admin.v2.TableR\x05table\x12Y\n\x0einitial_splits\x18\x04\x20\
    \x03(\x0b22.google.bigtable.admin.v2.CreateTableRequest.SplitR\rinitialS\
    plits\x1a\x19\n\x05Split\x12\x10\n\x03key\x18\x01\x20\x01(\x0cR\x03key\"\
    |\n\x1eCreateTableFromSnapshotRequest\x12\x16\n\x06parent\x18\x01\x20\
    \x01(\tR\x06parent\x12\x19\n\x08table_id\x18\x02\x20\x01(\tR\x07tableId\
    \x12'\n\x0fsource_snapshot\x18\x03\x20\x01(\tR\x0esourceSnapshot\"\x99\
    \x01\n\x13DropRowRangeRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04n\
    ame\x12&\n\x0erow_key_prefix\x18\x02\x20\x01(\x0cH\0R\x0crowKeyPrefix\
    \x12<\n\x1adelete_all_data_from_table\x18\x03\x20\x01(\x08H\0R\x16delete\
    AllDataFromTableB\x08\n\x06target\"\xa1\x01\n\x11ListTablesRequest\x12\
    \x16\n\x06parent\x18\x01\x20\x01(\tR\x06parent\x128\n\x04view\x18\x02\
    \x20\x01(\x0e2$.google.bigtable.admin.v2.Table.ViewR\x04view\x12\x1b\n\t\
    page_size\x18\x04\x20\x01(\x05R\x08pageSize\x12\x1d\n\npage_token\x18\
    \x03\x20\x01(\tR\tpageToken\"u\n\x12ListTablesResponse\x127\n\x06tables\
    \x18\x01\x20\x03(\x0b2\x1f.google.bigtable.admin.v2.TableR\x06tables\x12\
    &\n\x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\"_\n\x0fGetTab\
    leRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x128\n\x04view\
    \x18\x02\x20\x01(\x0e2$.google.bigtable.admin.v2.Table.ViewR\x04view\"(\
    \n\x12DeleteTableRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\"\
    \xdd\x02\n\x1bModifyColumnFamiliesRequest\x12\x12\n\x04name\x18\x01\x20\
    \x01(\tR\x04name\x12h\n\rmodifications\x18\x02\x20\x03(\x0b2B.google.big\
    table.admin.v2.ModifyColumnFamiliesRequest.ModificationR\rmodifications\
    \x1a\xbf\x01\n\x0cModification\x12\x0e\n\x02id\x18\x01\x20\x01(\tR\x02id\
    \x12@\n\x06create\x18\x02\x20\x01(\x0b2&.google.bigtable.admin.v2.Column\
    FamilyH\0R\x06create\x12@\n\x06update\x18\x03\x20\x01(\x0b2&.google.bigt\
    able.admin.v2.ColumnFamilyH\0R\x06update\x12\x14\n\x04drop\x18\x04\x20\
    \x01(\x08H\0R\x04dropB\x05\n\x03mod\"5\n\x1fGenerateConsistencyTokenRequ\
    est\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\"O\n\x20GenerateConsis\
    tencyTokenResponse\x12+\n\x11consistency_token\x18\x01\x20\x01(\tR\x10co\
    nsistencyToken\"Z\n\x17CheckConsistencyRequest\x12\x12\n\x04name\x18\x01\
    \x20\x01(\tR\x04name\x12+\n\x11consistency_token\x18\x02\x20\x01(\tR\x10\
    consistencyToken\":\n\x18CheckConsistencyResponse\x12\x1e\n\nconsistent\
    \x18\x01\x20\x01(\x08R\nconsistent\"\xb4\x01\n\x14SnapshotTableRequest\
    \x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x18\n\x07cluster\x18\
    \x02\x20\x01(\tR\x07cluster\x12\x1f\n\x0bsnapshot_id\x18\x03\x20\x01(\tR\
    \nsnapshotId\x12+\n\x03ttl\x18\x04\x20\x01(\x0b2\x19.google.protobuf.Dur\
    ationR\x03ttl\x12\x20\n\x0bdescription\x18\x05\x20\x01(\tR\x0bdescriptio\
    n\"(\n\x12GetSnapshotRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04na\
    me\"j\n\x14ListSnapshotsRequest\x12\x16\n\x06parent\x18\x01\x20\x01(\tR\
    \x06parent\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08pageSize\x12\
    \x1d\n\npage_token\x18\x03\x20\x01(\tR\tpageToken\"\x81\x01\n\x15ListSna\
    pshotsResponse\x12@\n\tsnapshots\x18\x01\x20\x03(\x0b2\".google.bigtable\
    .admin.v2.SnapshotR\tsnapshots\x12&\n\x0fnext_page_token\x18\x02\x20\x01\
    (\tR\rnextPageToken\"+\n\x15DeleteSnapshotRequest\x12\x12\n\x04name\x18\
    \x01\x20\x01(\tR\x04name\"\xee\x01\n\x15SnapshotTableMetadata\x12Y\n\x10\
    original_request\x18\x01\x20\x01(\x0b2..google.bigtable.admin.v2.Snapsho\
    tTableRequestR\x0foriginalRequest\x12=\n\x0crequest_time\x18\x02\x20\x01\
    (\x0b2\x1a.google.protobuf.TimestampR\x0brequestTime\x12;\n\x0bfinish_ti\
    me\x18\x03\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\nfinishTime\"\
    \x82\x02\n\x1fCreateTableFromSnapshotMetadata\x12c\n\x10original_request\
    \x18\x01\x20\x01(\x0b28.google.bigtable.admin.v2.CreateTableFromSnapshot\
    RequestR\x0foriginalRequest\x12=\n\x0crequest_time\x18\x02\x20\x01(\x0b2\
    \x1a.google.protobuf.TimestampR\x0brequestTime\x12;\n\x0bfinish_time\x18\
    \x03\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\nfinishTime2\x99\x15\n\
    \x12BigtableTableAdmin\x12\x93\x01\n\x0bCreateTable\x12,.google.bigtable\
    .admin.v2.CreateTableRequest\x1a\x1f.google.bigtable.admin.v2.Table\"5\
    \x82\xd3\xe4\x93\x02/\"*/v2/{parent=projects/*/instances/*}/tables:\x01*\
    \x12\xbc\x01\n\x17CreateTableFromSnapshot\x128.google.bigtable.admin.v2.\
    CreateTableFromSnapshotRequest\x1a\x1d.google.longrunning.Operation\"H\
    \x82\xd3\xe4\x93\x02B\"=/v2/{parent=projects/*/instances/*}/tables:creat\
    eFromSnapshot:\x01*\x12\x9b\x01\n\nListTables\x12+.google.bigtable.admin\
    .v2.ListTablesRequest\x1a,.google.bigtable.admin.v2.ListTablesResponse\"\
    2\x82\xd3\xe4\x93\x02,\x12*/v2/{parent=projects/*/instances/*}/tables\
    \x12\x8a\x01\n\x08GetTable\x12).google.bigtable.admin.v2.GetTableRequest\
    \x1a\x1f.google.bigtable.admin.v2.Table\"2\x82\xd3\xe4\x93\x02,\x12*/v2/\
    {name=projects/*/instances/*/tables/*}\x12\x87\x01\n\x0bDeleteTable\x12,\
    .google.bigtable.admin.v2.DeleteTableRequest\x1a\x16.google.protobuf.Emp\
    ty\"2\x82\xd3\xe4\x93\x02,**/v2/{name=projects/*/instances/*/tables/*}\
    \x12\xba\x01\n\x14ModifyColumnFamilies\x125.google.bigtable.admin.v2.Mod\
    ifyColumnFamiliesRequest\x1a\x1f.google.bigtable.admin.v2.Table\"J\x82\
    \xd3\xe4\x93\x02D\"?/v2/{name=projects/*/instances/*/tables/*}:modifyCol\
    umnFamilies:\x01*\x12\x99\x01\n\x0cDropRowRange\x12-.google.bigtable.adm\
    in.v2.DropRowRangeRequest\x1a\x16.google.protobuf.Empty\"B\x82\xd3\xe4\
    \x93\x02<\"7/v2/{name=projects/*/instances/*/tables/*}:dropRowRange:\x01\
    *\x12\xe1\x01\n\x18GenerateConsistencyToken\x129.google.bigtable.admin.v\
    2.GenerateConsistencyTokenRequest\x1a:.google.bigtable.admin.v2.Generate\
    ConsistencyTokenResponse\"N\x82\xd3\xe4\x93\x02H\"C/v2/{name=projects/*/\
    instances/*/tables/*}:generateConsistencyToken:\x01*\x12\xc1\x01\n\x10Ch\
    eckConsistency\x121.google.bigtable.admin.v2.CheckConsistencyRequest\x1a\
    2.google.bigtable.admin.v2.CheckConsistencyResponse\"F\x82\xd3\xe4\x93\
    \x02@\";/v2/{name=projects/*/instances/*/tables/*}:checkConsistency:\x01\
    *\x12\x9e\x01\n\rSnapshotTable\x12..google.bigtable.admin.v2.SnapshotTab\
    leRequest\x1a\x1d.google.longrunning.Operation\">\x82\xd3\xe4\x93\x028\"\
    3/v2/{name=projects/*/instances/*/tables/*}:snapshot:\x01*\x12\xa1\x01\n\
    \x0bGetSnapshot\x12,.google.bigtable.admin.v2.GetSnapshotRequest\x1a\".g\
    oogle.bigtable.admin.v2.Snapshot\"@\x82\xd3\xe4\x93\x02:\x128/v2/{name=p\
    rojects/*/instances/*/clusters/*/snapshots/*}\x12\xb2\x01\n\rListSnapsho\
    ts\x12..google.bigtable.admin.v2.ListSnapshotsRequest\x1a/.google.bigtab\
    le.admin.v2.ListSnapshotsResponse\"@\x82\xd3\xe4\x93\x02:\x128/v2/{paren\
    t=projects/*/instances/*/clusters/*}/snapshots\x12\x9b\x01\n\x0eDeleteSn\
    apshot\x12/.google.bigtable.admin.v2.DeleteSnapshotRequest\x1a\x16.googl\
    e.protobuf.Empty\"@\x82\xd3\xe4\x93\x02:*8/v2/{name=projects/*/instances\
    /*/clusters/*/snapshots/*}\x12\x91\x01\n\x0cGetIamPolicy\x12\".google.ia\
    m.v1.GetIamPolicyRequest\x1a\x15.google.iam.v1.Policy\"F\x82\xd3\xe4\x93\
    \x02@\";/v2/{resource=projects/*/instances/*/tables/*}:getIamPolicy:\x01\
    *\x12\x91\x01\n\x0cSetIamPolicy\x12\".google.iam.v1.SetIamPolicyRequest\
    \x1a\x15.google.iam.v1.Policy\"F\x82\xd3\xe4\x93\x02@\";/v2/{resource=pr\
    ojects/*/instances/*/tables/*}:setIamPolicy:\x01*\x12\xb7\x01\n\x12TestI\
    amPermissions\x12(.google.iam.v1.TestIamPermissionsRequest\x1a).google.i\
    am.v1.TestIamPermissionsResponse\"L\x82\xd3\xe4\x93\x02F\"A/v2/{resource\
    =projects/*/instances/*/tables/*}:testIamPermissions:\x01*B\xba\x01\n\
    \x1ccom.google.bigtable.admin.v2B\x17BigtableTableAdminProtoP\x01Z=googl\
    e.golang.org/genproto/googleapis/bigtable/admin/v2;admin\xaa\x02\x1eGoog\
    le.Cloud.Bigtable.Admin.V2\xca\x02\x1eGoogle\\Cloud\\Bigtable\\Admin\\V2\
    J\xca\xa6\x01\n\x07\x12\x05\x0f\0\xab\x04\x01\n\xbe\x04\n\x01\x0c\x12\
    \x03\x0f\0\x122\xb3\x04\x20Copyright\x202018\x20Google\x20LLC.\n\n\x20Li\
    censed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20(the\
    \x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20excep\
    t\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20obta\
    in\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\x20\x20htt\
    p://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20required\x20by\
    \x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\x20softwar\
    e\n\x20distributed\x20under\x20the\x20License\x20is\x20distributed\x20on\
    \x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CON\
    DITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20implied.\n\
    \x20See\x20the\x20License\x20for\x20the\x20specific\x20language\x20gover\
    ning\x20permissions\x20and\n\x20limitations\x20under\x20the\x20License.\
    \n\n\n\x08\n\x01\x02\x12\x03\x11\0!\n\t\n\x02\x03\0\x12\x03\x13\0&\n\t\n\
    \x02\x03\x01\x12\x03\x14\0.\n\t\n\x02\x03\x02\x12\x03\x15\0(\n\t\n\x02\
    \x03\x03\x12\x03\x16\0$\n\t\n\x02\x03\x04\x12\x03\x17\0-\n\t\n\x02\x03\
    \x05\x12\x03\x18\0(\n\t\n\x02\x03\x06\x12\x03\x19\0%\n\t\n\x02\x03\x07\
    \x12\x03\x1a\0)\n\x08\n\x01\x08\x12\x03\x1c\0;\n\t\n\x02\x08%\x12\x03\
    \x1c\0;\n\x08\n\x01\x08\x12\x03\x1d\0T\n\t\n\x02\x08\x0b\x12\x03\x1d\0T\
    \n\x08\n\x01\x08\x12\x03\x1e\0\"\n\t\n\x02\x08\n\x12\x03\x1e\0\"\n\x08\n\
    \x01\x08\x12\x03\x1f\08\n\t\n\x02\x08\x08\x12\x03\x1f\08\n\x08\n\x01\x08\
    \x12\x03\x20\05\n\t\n\x02\x08\x01\x12\x03\x20\05\n\x08\n\x01\x08\x12\x03\
    !\0<\n\t\n\x02\x08)\x12\x03!\0<\n\xac\x01\n\x02\x06\0\x12\x05(\0\xd4\x01\
    \x01\x1a\x9e\x01\x20Service\x20for\x20creating,\x20configuring,\x20and\
    \x20deleting\x20Cloud\x20Bigtable\x20tables.\n\n\n\x20Provides\x20access\
    \x20to\x20the\x20table\x20schemas\x20only,\x20not\x20the\x20data\x20stor\
    ed\x20within\n\x20the\x20tables.\n\n\n\n\x03\x06\0\x01\x12\x03(\x08\x1a\
    \n\xa0\x01\n\x04\x06\0\x02\0\x12\x04,\x021\x03\x1a\x91\x01\x20Creates\
    \x20a\x20new\x20table\x20in\x20the\x20specified\x20instance.\n\x20The\
    \x20table\x20can\x20be\x20created\x20with\x20a\x20full\x20set\x20of\x20i\
    nitial\x20column\x20families,\n\x20specified\x20in\x20the\x20request.\n\
    \n\x0c\n\x05\x06\0\x02\0\x01\x12\x03,\x06\x11\n\x0c\n\x05\x06\0\x02\0\
    \x02\x12\x03,\x12$\n\x0c\n\x05\x06\0\x02\0\x03\x12\x03,/4\n\r\n\x05\x06\
    \0\x02\0\x04\x12\x04-\x040\x06\n\x11\n\t\x06\0\x02\0\x04\xb0\xca\xbc\"\
    \x12\x04-\x040\x06\n\xca\x03\n\x04\x06\0\x02\x01\x12\x04;\x02A\x03\x1a\
    \xbb\x03\x20Creates\x20a\x20new\x20table\x20from\x20the\x20specified\x20\
    snapshot.\x20The\x20target\x20table\x20must\n\x20not\x20exist.\x20The\
    \x20snapshot\x20and\x20the\x20table\x20must\x20be\x20in\x20the\x20same\
    \x20instance.\n\n\x20Note:\x20This\x20is\x20a\x20private\x20alpha\x20rel\
    ease\x20of\x20Cloud\x20Bigtable\x20snapshots.\x20This\n\x20feature\x20is\
    \x20not\x20currently\x20available\x20to\x20most\x20Cloud\x20Bigtable\x20\
    customers.\x20This\n\x20feature\x20might\x20be\x20changed\x20in\x20backw\
    ard-incompatible\x20ways\x20and\x20is\x20not\n\x20recommended\x20for\x20\
    production\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20\
    or\x20deprecation\n\x20policy.\n\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x03;\
    \x06\x1d\n\x0c\n\x05\x06\0\x02\x01\x02\x12\x03;\x1e<\n\x0c\n\x05\x06\0\
    \x02\x01\x03\x12\x03<\x0f+\n\r\n\x05\x06\0\x02\x01\x04\x12\x04=\x04@\x06\
    \n\x11\n\t\x06\0\x02\x01\x04\xb0\xca\xbc\"\x12\x04=\x04@\x06\nB\n\x04\
    \x06\0\x02\x02\x12\x04D\x02H\x03\x1a4\x20Lists\x20all\x20tables\x20serve\
    d\x20from\x20a\x20specified\x20instance.\n\n\x0c\n\x05\x06\0\x02\x02\x01\
    \x12\x03D\x06\x10\n\x0c\n\x05\x06\0\x02\x02\x02\x12\x03D\x11\"\n\x0c\n\
    \x05\x06\0\x02\x02\x03\x12\x03D-?\n\r\n\x05\x06\0\x02\x02\x04\x12\x04E\
    \x04G\x06\n\x11\n\t\x06\0\x02\x02\x04\xb0\xca\xbc\"\x12\x04E\x04G\x06\nD\
    \n\x04\x06\0\x02\x03\x12\x04K\x02O\x03\x1a6\x20Gets\x20metadata\x20infor\
    mation\x20about\x20the\x20specified\x20table.\n\n\x0c\n\x05\x06\0\x02\
    \x03\x01\x12\x03K\x06\x0e\n\x0c\n\x05\x06\0\x02\x03\x02\x12\x03K\x0f\x1e\
    \n\x0c\n\x05\x06\0\x02\x03\x03\x12\x03K).\n\r\n\x05\x06\0\x02\x03\x04\
    \x12\x04L\x04N\x06\n\x11\n\t\x06\0\x02\x03\x04\xb0\xca\xbc\"\x12\x04L\
    \x04N\x06\nJ\n\x04\x06\0\x02\x04\x12\x04R\x02V\x03\x1a<\x20Permanently\
    \x20deletes\x20a\x20specified\x20table\x20and\x20all\x20of\x20its\x20dat\
    a.\n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\x03R\x06\x11\n\x0c\n\x05\x06\0\
    \x02\x04\x02\x12\x03R\x12$\n\x0c\n\x05\x06\0\x02\x04\x03\x12\x03R/D\n\r\
    \n\x05\x06\0\x02\x04\x04\x12\x04S\x04U\x06\n\x11\n\t\x06\0\x02\x04\x04\
    \xb0\xca\xbc\"\x12\x04S\x04U\x06\n\x9b\x02\n\x04\x06\0\x02\x05\x12\x04\\\
    \x02a\x03\x1a\x8c\x02\x20Performs\x20a\x20series\x20of\x20column\x20fami\
    ly\x20modifications\x20on\x20the\x20specified\x20table.\n\x20Either\x20a\
    ll\x20or\x20none\x20of\x20the\x20modifications\x20will\x20occur\x20befor\
    e\x20this\x20method\n\x20returns,\x20but\x20data\x20requests\x20received\
    \x20prior\x20to\x20that\x20point\x20may\x20see\x20a\x20table\n\x20where\
    \x20only\x20some\x20modifications\x20have\x20taken\x20effect.\n\n\x0c\n\
    \x05\x06\0\x02\x05\x01\x12\x03\\\x06\x1a\n\x0c\n\x05\x06\0\x02\x05\x02\
    \x12\x03\\\x1b6\n\x0c\n\x05\x06\0\x02\x05\x03\x12\x03\\AF\n\r\n\x05\x06\
    \0\x02\x05\x04\x12\x04]\x04`\x06\n\x11\n\t\x06\0\x02\x05\x04\xb0\xca\xbc\
    \"\x12\x04]\x04`\x06\n\xbb\x01\n\x04\x06\0\x02\x06\x12\x04f\x02k\x03\x1a\
    \xac\x01\x20Permanently\x20drop/delete\x20a\x20row\x20range\x20from\x20a\
    \x20specified\x20table.\x20The\x20request\x20can\n\x20specify\x20whether\
    \x20to\x20delete\x20all\x20rows\x20in\x20a\x20table,\x20or\x20only\x20th\
    ose\x20that\x20match\x20a\n\x20particular\x20prefix.\n\n\x0c\n\x05\x06\0\
    \x02\x06\x01\x12\x03f\x06\x12\n\x0c\n\x05\x06\0\x02\x06\x02\x12\x03f\x13\
    &\n\x0c\n\x05\x06\0\x02\x06\x03\x12\x03f1F\n\r\n\x05\x06\0\x02\x06\x04\
    \x12\x04g\x04j\x06\n\x11\n\t\x06\0\x02\x06\x04\xb0\xca\xbc\"\x12\x04g\
    \x04j\x06\n\xf3\x01\n\x04\x06\0\x02\x07\x12\x04q\x02w\x03\x1a\xe4\x01\
    \x20Generates\x20a\x20consistency\x20token\x20for\x20a\x20Table,\x20whic\
    h\x20can\x20be\x20used\x20in\n\x20CheckConsistency\x20to\x20check\x20whe\
    ther\x20mutations\x20to\x20the\x20table\x20that\x20finished\n\x20before\
    \x20this\x20call\x20started\x20have\x20been\x20replicated.\x20The\x20tok\
    ens\x20will\x20be\x20available\n\x20for\x2090\x20days.\n\n\x0c\n\x05\x06\
    \0\x02\x07\x01\x12\x03q\x06\x1e\n\x0c\n\x05\x06\0\x02\x07\x02\x12\x03q\
    \x1f>\n\x0c\n\x05\x06\0\x02\x07\x03\x12\x03r\x0f/\n\r\n\x05\x06\0\x02\
    \x07\x04\x12\x04s\x04v\x06\n\x11\n\t\x06\0\x02\x07\x04\xb0\xca\xbc\"\x12\
    \x04s\x04v\x06\n\xbc\x01\n\x04\x06\0\x02\x08\x12\x05|\x02\x82\x01\x03\
    \x1a\xac\x01\x20Checks\x20replication\x20consistency\x20based\x20on\x20a\
    \x20consistency\x20token,\x20that\x20is,\x20if\n\x20replication\x20has\
    \x20caught\x20up\x20based\x20on\x20the\x20conditions\x20specified\x20in\
    \x20the\x20token\n\x20and\x20the\x20check\x20request.\n\n\x0c\n\x05\x06\
    \0\x02\x08\x01\x12\x03|\x06\x16\n\x0c\n\x05\x06\0\x02\x08\x02\x12\x03|\
    \x17.\n\x0c\n\x05\x06\0\x02\x08\x03\x12\x03}\x0f'\n\x0e\n\x05\x06\0\x02\
    \x08\x04\x12\x05~\x04\x81\x01\x06\n\x12\n\t\x06\0\x02\x08\x04\xb0\xca\
    \xbc\"\x12\x05~\x04\x81\x01\x06\n\xca\x03\n\x04\x06\0\x02\t\x12\x06\x8c\
    \x01\x02\x92\x01\x03\x1a\xb9\x03\x20Creates\x20a\x20new\x20snapshot\x20i\
    n\x20the\x20specified\x20cluster\x20from\x20the\x20specified\n\x20source\
    \x20table.\x20The\x20cluster\x20and\x20the\x20table\x20must\x20be\x20in\
    \x20the\x20same\x20instance.\n\n\x20Note:\x20This\x20is\x20a\x20private\
    \x20alpha\x20release\x20of\x20Cloud\x20Bigtable\x20snapshots.\x20This\n\
    \x20feature\x20is\x20not\x20currently\x20available\x20to\x20most\x20Clou\
    d\x20Bigtable\x20customers.\x20This\n\x20feature\x20might\x20be\x20chang\
    ed\x20in\x20backward-incompatible\x20ways\x20and\x20is\x20not\n\x20recom\
    mended\x20for\x20production\x20use.\x20It\x20is\x20not\x20subject\x20to\
    \x20any\x20SLA\x20or\x20deprecation\n\x20policy.\n\n\r\n\x05\x06\0\x02\t\
    \x01\x12\x04\x8c\x01\x06\x13\n\r\n\x05\x06\0\x02\t\x02\x12\x04\x8c\x01\
    \x14(\n\r\n\x05\x06\0\x02\t\x03\x12\x04\x8d\x01\x0f+\n\x0f\n\x05\x06\0\
    \x02\t\x04\x12\x06\x8e\x01\x04\x91\x01\x06\n\x13\n\t\x06\0\x02\t\x04\xb0\
    \xca\xbc\"\x12\x06\x8e\x01\x04\x91\x01\x06\n\xf8\x02\n\x04\x06\0\x02\n\
    \x12\x06\x9b\x01\x02\x9f\x01\x03\x1a\xe7\x02\x20Gets\x20metadata\x20info\
    rmation\x20about\x20the\x20specified\x20snapshot.\n\n\x20Note:\x20This\
    \x20is\x20a\x20private\x20alpha\x20release\x20of\x20Cloud\x20Bigtable\
    \x20snapshots.\x20This\n\x20feature\x20is\x20not\x20currently\x20availab\
    le\x20to\x20most\x20Cloud\x20Bigtable\x20customers.\x20This\n\x20feature\
    \x20might\x20be\x20changed\x20in\x20backward-incompatible\x20ways\x20and\
    \x20is\x20not\n\x20recommended\x20for\x20production\x20use.\x20It\x20is\
    \x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\n\x20policy.\
    \n\n\r\n\x05\x06\0\x02\n\x01\x12\x04\x9b\x01\x06\x11\n\r\n\x05\x06\0\x02\
    \n\x02\x12\x04\x9b\x01\x12$\n\r\n\x05\x06\0\x02\n\x03\x12\x04\x9b\x01/7\
    \n\x0f\n\x05\x06\0\x02\n\x04\x12\x06\x9c\x01\x04\x9e\x01\x06\n\x13\n\t\
    \x06\0\x02\n\x04\xb0\xca\xbc\"\x12\x06\x9c\x01\x04\x9e\x01\x06\n\xfb\x02\
    \n\x04\x06\0\x02\x0b\x12\x06\xa8\x01\x02\xac\x01\x03\x1a\xea\x02\x20List\
    s\x20all\x20snapshots\x20associated\x20with\x20the\x20specified\x20clust\
    er.\n\n\x20Note:\x20This\x20is\x20a\x20private\x20alpha\x20release\x20of\
    \x20Cloud\x20Bigtable\x20snapshots.\x20This\n\x20feature\x20is\x20not\
    \x20currently\x20available\x20to\x20most\x20Cloud\x20Bigtable\x20custome\
    rs.\x20This\n\x20feature\x20might\x20be\x20changed\x20in\x20backward-inc\
    ompatible\x20ways\x20and\x20is\x20not\n\x20recommended\x20for\x20product\
    ion\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20d\
    eprecation\n\x20policy.\n\n\r\n\x05\x06\0\x02\x0b\x01\x12\x04\xa8\x01\
    \x06\x13\n\r\n\x05\x06\0\x02\x0b\x02\x12\x04\xa8\x01\x14(\n\r\n\x05\x06\
    \0\x02\x0b\x03\x12\x04\xa8\x013H\n\x0f\n\x05\x06\0\x02\x0b\x04\x12\x06\
    \xa9\x01\x04\xab\x01\x06\n\x13\n\t\x06\0\x02\x0b\x04\xb0\xca\xbc\"\x12\
    \x06\xa9\x01\x04\xab\x01\x06\n\xec\x02\n\x04\x06\0\x02\x0c\x12\x06\xb5\
    \x01\x02\xb9\x01\x03\x1a\xdb\x02\x20Permanently\x20deletes\x20the\x20spe\
    cified\x20snapshot.\n\n\x20Note:\x20This\x20is\x20a\x20private\x20alpha\
    \x20release\x20of\x20Cloud\x20Bigtable\x20snapshots.\x20This\n\x20featur\
    e\x20is\x20not\x20currently\x20available\x20to\x20most\x20Cloud\x20Bigta\
    ble\x20customers.\x20This\n\x20feature\x20might\x20be\x20changed\x20in\
    \x20backward-incompatible\x20ways\x20and\x20is\x20not\n\x20recommended\
    \x20for\x20production\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\
    \x20SLA\x20or\x20deprecation\n\x20policy.\n\n\r\n\x05\x06\0\x02\x0c\x01\
    \x12\x04\xb5\x01\x06\x14\n\r\n\x05\x06\0\x02\x0c\x02\x12\x04\xb5\x01\x15\
    *\n\r\n\x05\x06\0\x02\x0c\x03\x12\x04\xb5\x015J\n\x0f\n\x05\x06\0\x02\
    \x0c\x04\x12\x06\xb6\x01\x04\xb8\x01\x06\n\x13\n\t\x06\0\x02\x0c\x04\xb0\
    \xca\xbc\"\x12\x06\xb6\x01\x04\xb8\x01\x06\n\x93\x01\n\x04\x06\0\x02\r\
    \x12\x06\xbd\x01\x02\xc2\x01\x03\x1a\x82\x01\x20Gets\x20the\x20access\
    \x20control\x20policy\x20for\x20a\x20table\x20resource.\x20Returns\x20an\
    \x20empty\n\x20policy\x20if\x20an\x20table\x20exists\x20but\x20does\x20n\
    ot\x20have\x20a\x20policy\x20set.\n\n\r\n\x05\x06\0\x02\r\x01\x12\x04\
    \xbd\x01\x06\x12\n\r\n\x05\x06\0\x02\r\x02\x12\x04\xbd\x01\x134\n\r\n\
    \x05\x06\0\x02\r\x03\x12\x04\xbd\x01?S\n\x0f\n\x05\x06\0\x02\r\x04\x12\
    \x06\xbe\x01\x04\xc1\x01\x06\n\x13\n\t\x06\0\x02\r\x04\xb0\xca\xbc\"\x12\
    \x06\xbe\x01\x04\xc1\x01\x06\nd\n\x04\x06\0\x02\x0e\x12\x06\xc6\x01\x02\
    \xcb\x01\x03\x1aT\x20Sets\x20the\x20access\x20control\x20policy\x20on\
    \x20a\x20table\x20resource.\x20Replaces\x20any\x20existing\n\x20policy.\
    \n\n\r\n\x05\x06\0\x02\x0e\x01\x12\x04\xc6\x01\x06\x12\n\r\n\x05\x06\0\
    \x02\x0e\x02\x12\x04\xc6\x01\x134\n\r\n\x05\x06\0\x02\x0e\x03\x12\x04\
    \xc6\x01?S\n\x0f\n\x05\x06\0\x02\x0e\x04\x12\x06\xc7\x01\x04\xca\x01\x06\
    \n\x13\n\t\x06\0\x02\x0e\x04\xb0\xca\xbc\"\x12\x06\xc7\x01\x04\xca\x01\
    \x06\nZ\n\x04\x06\0\x02\x0f\x12\x06\xce\x01\x02\xd3\x01\x03\x1aJ\x20Retu\
    rns\x20permissions\x20that\x20the\x20caller\x20has\x20on\x20the\x20speci\
    fied\x20table\x20resource.\n\n\r\n\x05\x06\0\x02\x0f\x01\x12\x04\xce\x01\
    \x06\x18\n\r\n\x05\x06\0\x02\x0f\x02\x12\x04\xce\x01\x19@\n\r\n\x05\x06\
    \0\x02\x0f\x03\x12\x04\xce\x01Ks\n\x0f\n\x05\x06\0\x02\x0f\x04\x12\x06\
    \xcf\x01\x04\xd2\x01\x06\n\x13\n\t\x06\0\x02\x0f\x04\xb0\xca\xbc\"\x12\
    \x06\xcf\x01\x04\xd2\x01\x06\n\x98\x01\n\x02\x04\0\x12\x06\xd8\x01\0\xfb\
    \x01\x01\x1a\x89\x01\x20Request\x20message\x20for\n\x20[google.bigtable.\
    admin.v2.BigtableTableAdmin.CreateTable][google.bigtable.admin.v2.Bigtab\
    leTableAdmin.CreateTable]\n\n\x0b\n\x03\x04\0\x01\x12\x04\xd8\x01\x08\
    \x1a\nC\n\x04\x04\0\x03\0\x12\x06\xda\x01\x02\xdd\x01\x03\x1a3\x20An\x20\
    initial\x20split\x20point\x20for\x20a\x20newly\x20created\x20table.\n\n\
    \r\n\x05\x04\0\x03\0\x01\x12\x04\xda\x01\n\x0f\n?\n\x06\x04\0\x03\0\x02\
    \0\x12\x04\xdc\x01\x04\x12\x1a/\x20Row\x20key\x20to\x20use\x20as\x20an\
    \x20initial\x20tablet\x20boundary.\n\n\x0f\n\x07\x04\0\x03\0\x02\0\x05\
    \x12\x04\xdc\x01\x04\t\n\x0f\n\x07\x04\0\x03\0\x02\0\x01\x12\x04\xdc\x01\
    \n\r\n\x0f\n\x07\x04\0\x03\0\x02\0\x03\x12\x04\xdc\x01\x10\x11\n\x91\x01\
    \n\x04\x04\0\x02\0\x12\x04\xe1\x01\x02\x14\x1a\x82\x01\x20The\x20unique\
    \x20name\x20of\x20the\x20instance\x20in\x20which\x20to\x20create\x20the\
    \x20table.\n\x20Values\x20are\x20of\x20the\x20form\x20`projects/<project\
    >/instances/<instance>`.\n\n\r\n\x05\x04\0\x02\0\x05\x12\x04\xe1\x01\x02\
    \x08\n\r\n\x05\x04\0\x02\0\x01\x12\x04\xe1\x01\t\x0f\n\r\n\x05\x04\0\x02\
    \0\x03\x12\x04\xe1\x01\x12\x13\n\x98\x01\n\x04\x04\0\x02\x01\x12\x04\xe5\
    \x01\x02\x16\x1a\x89\x01\x20The\x20name\x20by\x20which\x20the\x20new\x20\
    table\x20should\x20be\x20referred\x20to\x20within\x20the\x20parent\n\x20\
    instance,\x20e.g.,\x20`foobar`\x20rather\x20than\x20`<parent>/tables/foo\
    bar`.\n\n\r\n\x05\x04\0\x02\x01\x05\x12\x04\xe5\x01\x02\x08\n\r\n\x05\
    \x04\0\x02\x01\x01\x12\x04\xe5\x01\t\x11\n\r\n\x05\x04\0\x02\x01\x03\x12\
    \x04\xe5\x01\x14\x15\n$\n\x04\x04\0\x02\x02\x12\x04\xe8\x01\x02\x12\x1a\
    \x16\x20The\x20Table\x20to\x20create.\n\n\r\n\x05\x04\0\x02\x02\x06\x12\
    \x04\xe8\x01\x02\x07\n\r\n\x05\x04\0\x02\x02\x01\x12\x04\xe8\x01\x08\r\n\
    \r\n\x05\x04\0\x02\x02\x03\x12\x04\xe8\x01\x10\x11\n\x99\x06\n\x04\x04\0\
    \x02\x03\x12\x04\xfa\x01\x02$\x1a\x8a\x06\x20The\x20optional\x20list\x20\
    of\x20row\x20keys\x20that\x20will\x20be\x20used\x20to\x20initially\x20sp\
    lit\x20the\n\x20table\x20into\x20several\x20tablets\x20(tablets\x20are\
    \x20similar\x20to\x20HBase\x20regions).\n\x20Given\x20two\x20split\x20ke\
    ys,\x20`s1`\x20and\x20`s2`,\x20three\x20tablets\x20will\x20be\x20created\
    ,\n\x20spanning\x20the\x20key\x20ranges:\x20`[,\x20s1),\x20[s1,\x20s2),\
    \x20[s2,\x20)`.\n\n\x20Example:\n\n\x20*\x20Row\x20keys\x20:=\x20`[\"a\"\
    ,\x20\"apple\",\x20\"custom\",\x20\"customer_1\",\x20\"customer_2\",`\n\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20`\"other\
    \",\x20\"zz\"]`\n\x20*\x20initial_split_keys\x20:=\x20`[\"apple\",\x20\"\
    customer_1\",\x20\"customer_2\",\x20\"other\"]`\n\x20*\x20Key\x20assignm\
    ent:\n\x20\x20\x20\x20\x20-\x20Tablet\x201\x20`[,\x20apple)\x20\x20\x20\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20=>\x20{\"a\"}.`\n\
    \x20\x20\x20\x20\x20-\x20Tablet\x202\x20`[apple,\x20customer_1)\x20\x20\
    \x20\x20\x20\x20=>\x20{\"apple\",\x20\"custom\"}.`\n\x20\x20\x20\x20\x20\
    -\x20Tablet\x203\x20`[customer_1,\x20customer_2)\x20=>\x20{\"customer_1\
    \"}.`\n\x20\x20\x20\x20\x20-\x20Tablet\x204\x20`[customer_2,\x20other)\
    \x20\x20\x20\x20\x20\x20=>\x20{\"customer_2\"}.`\n\x20\x20\x20\x20\x20-\
    \x20Tablet\x205\x20`[other,\x20)\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20\x20\x20\x20\x20\x20=>\x20{\"other\",\x20\"zz\"}.`\n\n\r\n\x05\x04\0\
    \x02\x03\x04\x12\x04\xfa\x01\x02\n\n\r\n\x05\x04\0\x02\x03\x06\x12\x04\
    \xfa\x01\x0b\x10\n\r\n\x05\x04\0\x02\x03\x01\x12\x04\xfa\x01\x11\x1f\n\r\
    \n\x05\x04\0\x02\x03\x03\x12\x04\xfa\x01\"#\n\xdd\x03\n\x02\x04\x01\x12\
    \x06\x84\x02\0\x92\x02\x01\x1a\xce\x03\x20Request\x20message\x20for\n\
    \x20[google.bigtable.admin.v2.BigtableTableAdmin.CreateTableFromSnapshot\
    ][google.bigtable.admin.v2.BigtableTableAdmin.CreateTableFromSnapshot]\n\
    \n\x20Note:\x20This\x20is\x20a\x20private\x20alpha\x20release\x20of\x20C\
    loud\x20Bigtable\x20snapshots.\x20This\n\x20feature\x20is\x20not\x20curr\
    ently\x20available\x20to\x20most\x20Cloud\x20Bigtable\x20customers.\x20T\
    his\n\x20feature\x20might\x20be\x20changed\x20in\x20backward-incompatibl\
    e\x20ways\x20and\x20is\x20not\x20recommended\n\x20for\x20production\x20u\
    se.\x20It\x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecati\
    on\x20policy.\n\n\x0b\n\x03\x04\x01\x01\x12\x04\x84\x02\x08&\n\x91\x01\n\
    \x04\x04\x01\x02\0\x12\x04\x87\x02\x02\x14\x1a\x82\x01\x20The\x20unique\
    \x20name\x20of\x20the\x20instance\x20in\x20which\x20to\x20create\x20the\
    \x20table.\n\x20Values\x20are\x20of\x20the\x20form\x20`projects/<project\
    >/instances/<instance>`.\n\n\r\n\x05\x04\x01\x02\0\x05\x12\x04\x87\x02\
    \x02\x08\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\x87\x02\t\x0f\n\r\n\x05\x04\
    \x01\x02\0\x03\x12\x04\x87\x02\x12\x13\n\x98\x01\n\x04\x04\x01\x02\x01\
    \x12\x04\x8b\x02\x02\x16\x1a\x89\x01\x20The\x20name\x20by\x20which\x20th\
    e\x20new\x20table\x20should\x20be\x20referred\x20to\x20within\x20the\x20\
    parent\n\x20instance,\x20e.g.,\x20`foobar`\x20rather\x20than\x20`<parent\
    >/tables/foobar`.\n\n\r\n\x05\x04\x01\x02\x01\x05\x12\x04\x8b\x02\x02\
    \x08\n\r\n\x05\x04\x01\x02\x01\x01\x12\x04\x8b\x02\t\x11\n\r\n\x05\x04\
    \x01\x02\x01\x03\x12\x04\x8b\x02\x14\x15\n\xf7\x01\n\x04\x04\x01\x02\x02\
    \x12\x04\x91\x02\x02\x1d\x1a\xe8\x01\x20The\x20unique\x20name\x20of\x20t\
    he\x20snapshot\x20from\x20which\x20to\x20restore\x20the\x20table.\x20The\
    \n\x20snapshot\x20and\x20the\x20table\x20must\x20be\x20in\x20the\x20same\
    \x20instance.\n\x20Values\x20are\x20of\x20the\x20form\n\x20`projects/<pr\
    oject>/instances/<instance>/clusters/<cluster>/snapshots/<snapshot>`.\n\
    \n\r\n\x05\x04\x01\x02\x02\x05\x12\x04\x91\x02\x02\x08\n\r\n\x05\x04\x01\
    \x02\x02\x01\x12\x04\x91\x02\t\x18\n\r\n\x05\x04\x01\x02\x02\x03\x12\x04\
    \x91\x02\x1b\x1c\n\x9a\x01\n\x02\x04\x02\x12\x06\x96\x02\0\xa5\x02\x01\
    \x1a\x8b\x01\x20Request\x20message\x20for\n\x20[google.bigtable.admin.v2\
    .BigtableTableAdmin.DropRowRange][google.bigtable.admin.v2.BigtableTable\
    Admin.DropRowRange]\n\n\x0b\n\x03\x04\x02\x01\x12\x04\x96\x02\x08\x1b\n\
    \xa2\x01\n\x04\x04\x02\x02\0\x12\x04\x9a\x02\x02\x12\x1a\x93\x01\x20The\
    \x20unique\x20name\x20of\x20the\x20table\x20on\x20which\x20to\x20drop\
    \x20a\x20range\x20of\x20rows.\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\x9a\x02\x02\x08\n\r\n\x05\x04\x02\x02\0\
    \x01\x12\x04\x9a\x02\t\r\n\r\n\x05\x04\x02\x02\0\x03\x12\x04\x9a\x02\x10\
    \x11\n/\n\x04\x04\x02\x08\0\x12\x06\x9d\x02\x02\xa4\x02\x03\x1a\x1f\x20D\
    elete\x20all\x20rows\x20or\x20by\x20prefix.\n\n\r\n\x05\x04\x02\x08\0\
    \x01\x12\x04\x9d\x02\x08\x0e\nc\n\x04\x04\x02\x02\x01\x12\x04\xa0\x02\
    \x04\x1d\x1aU\x20Delete\x20all\x20rows\x20that\x20start\x20with\x20this\
    \x20row\x20key\x20prefix.\x20Prefix\x20cannot\x20be\n\x20zero\x20length.\
    \n\n\r\n\x05\x04\x02\x02\x01\x05\x12\x04\xa0\x02\x04\t\n\r\n\x05\x04\x02\
    \x02\x01\x01\x12\x04\xa0\x02\n\x18\n\r\n\x05\x04\x02\x02\x01\x03\x12\x04\
    \xa0\x02\x1b\x1c\nO\n\x04\x04\x02\x02\x02\x12\x04\xa3\x02\x04(\x1aA\x20D\
    elete\x20all\x20rows\x20in\x20the\x20table.\x20Setting\x20this\x20to\x20\
    false\x20is\x20a\x20no-op.\n\n\r\n\x05\x04\x02\x02\x02\x05\x12\x04\xa3\
    \x02\x04\x08\n\r\n\x05\x04\x02\x02\x02\x01\x12\x04\xa3\x02\t#\n\r\n\x05\
    \x04\x02\x02\x02\x03\x12\x04\xa3\x02&'\n\x96\x01\n\x02\x04\x03\x12\x06\
    \xa9\x02\0\xb8\x02\x01\x1a\x87\x01\x20Request\x20message\x20for\n\x20[go\
    ogle.bigtable.admin.v2.BigtableTableAdmin.ListTables][google.bigtable.ad\
    min.v2.BigtableTableAdmin.ListTables]\n\n\x0b\n\x03\x04\x03\x01\x12\x04\
    \xa9\x02\x08\x19\n\x96\x01\n\x04\x04\x03\x02\0\x12\x04\xac\x02\x02\x14\
    \x1a\x87\x01\x20The\x20unique\x20name\x20of\x20the\x20instance\x20for\
    \x20which\x20tables\x20should\x20be\x20listed.\n\x20Values\x20are\x20of\
    \x20the\x20form\x20`projects/<project>/instances/<instance>`.\n\n\r\n\
    \x05\x04\x03\x02\0\x05\x12\x04\xac\x02\x02\x08\n\r\n\x05\x04\x03\x02\0\
    \x01\x12\x04\xac\x02\t\x0f\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\xac\x02\
    \x12\x13\n\x93\x01\n\x04\x04\x03\x02\x01\x12\x04\xb0\x02\x02\x16\x1a\x84\
    \x01\x20The\x20view\x20to\x20be\x20applied\x20to\x20the\x20returned\x20t\
    ables'\x20fields.\n\x20Defaults\x20to\x20`NAME_ONLY`\x20if\x20unspecifie\
    d;\x20no\x20others\x20are\x20currently\x20supported.\n\n\r\n\x05\x04\x03\
    \x02\x01\x06\x12\x04\xb0\x02\x02\x0c\n\r\n\x05\x04\x03\x02\x01\x01\x12\
    \x04\xb0\x02\r\x11\n\r\n\x05\x04\x03\x02\x01\x03\x12\x04\xb0\x02\x14\x15\
    \nY\n\x04\x04\x03\x02\x02\x12\x04\xb4\x02\x02\x16\x1aK\x20Maximum\x20num\
    ber\x20of\x20results\x20per\x20page.\n\x20CURRENTLY\x20UNIMPLEMENTED\x20\
    AND\x20IGNORED.\n\n\r\n\x05\x04\x03\x02\x02\x05\x12\x04\xb4\x02\x02\x07\
    \n\r\n\x05\x04\x03\x02\x02\x01\x12\x04\xb4\x02\x08\x11\n\r\n\x05\x04\x03\
    \x02\x02\x03\x12\x04\xb4\x02\x14\x15\nK\n\x04\x04\x03\x02\x03\x12\x04\
    \xb7\x02\x02\x18\x1a=\x20The\x20value\x20of\x20`next_page_token`\x20retu\
    rned\x20by\x20a\x20previous\x20call.\n\n\r\n\x05\x04\x03\x02\x03\x05\x12\
    \x04\xb7\x02\x02\x08\n\r\n\x05\x04\x03\x02\x03\x01\x12\x04\xb7\x02\t\x13\
    \n\r\n\x05\x04\x03\x02\x03\x03\x12\x04\xb7\x02\x16\x17\n\x97\x01\n\x02\
    \x04\x04\x12\x06\xbc\x02\0\xc4\x02\x01\x1a\x88\x01\x20Response\x20messag\
    e\x20for\n\x20[google.bigtable.admin.v2.BigtableTableAdmin.ListTables][g\
    oogle.bigtable.admin.v2.BigtableTableAdmin.ListTables]\n\n\x0b\n\x03\x04\
    \x04\x01\x12\x04\xbc\x02\x08\x1a\n=\n\x04\x04\x04\x02\0\x12\x04\xbe\x02\
    \x02\x1c\x1a/\x20The\x20tables\x20present\x20in\x20the\x20requested\x20i\
    nstance.\n\n\r\n\x05\x04\x04\x02\0\x04\x12\x04\xbe\x02\x02\n\n\r\n\x05\
    \x04\x04\x02\0\x06\x12\x04\xbe\x02\x0b\x10\n\r\n\x05\x04\x04\x02\0\x01\
    \x12\x04\xbe\x02\x11\x17\n\r\n\x05\x04\x04\x02\0\x03\x12\x04\xbe\x02\x1a\
    \x1b\n\xa4\x01\n\x04\x04\x04\x02\x01\x12\x04\xc3\x02\x02\x1d\x1a\x95\x01\
    \x20Set\x20if\x20not\x20all\x20tables\x20could\x20be\x20returned\x20in\
    \x20a\x20single\x20response.\n\x20Pass\x20this\x20value\x20to\x20`page_t\
    oken`\x20in\x20another\x20request\x20to\x20get\x20the\x20next\n\x20page\
    \x20of\x20results.\n\n\r\n\x05\x04\x04\x02\x01\x05\x12\x04\xc3\x02\x02\
    \x08\n\r\n\x05\x04\x04\x02\x01\x01\x12\x04\xc3\x02\t\x18\n\r\n\x05\x04\
    \x04\x02\x01\x03\x12\x04\xc3\x02\x1b\x1c\n\x92\x01\n\x02\x04\x05\x12\x06\
    \xc8\x02\0\xd1\x02\x01\x1a\x83\x01\x20Request\x20message\x20for\n\x20[go\
    ogle.bigtable.admin.v2.BigtableTableAdmin.GetTable][google.bigtable.admi\
    n.v2.BigtableTableAdmin.GetTable]\n\n\x0b\n\x03\x04\x05\x01\x12\x04\xc8\
    \x02\x08\x17\n\x8a\x01\n\x04\x04\x05\x02\0\x12\x04\xcc\x02\x02\x12\x1a|\
    \x20The\x20unique\x20name\x20of\x20the\x20requested\x20table.\n\x20Value\
    s\x20are\x20of\x20the\x20form\n\x20`projects/<project>/instances/<instan\
    ce>/tables/<table>`.\n\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\xcc\x02\x02\
    \x08\n\r\n\x05\x04\x05\x02\0\x01\x12\x04\xcc\x02\t\r\n\r\n\x05\x04\x05\
    \x02\0\x03\x12\x04\xcc\x02\x10\x11\nq\n\x04\x04\x05\x02\x01\x12\x04\xd0\
    \x02\x02\x16\x1ac\x20The\x20view\x20to\x20be\x20applied\x20to\x20the\x20\
    returned\x20table's\x20fields.\n\x20Defaults\x20to\x20`SCHEMA_VIEW`\x20i\
    f\x20unspecified.\n\n\r\n\x05\x04\x05\x02\x01\x06\x12\x04\xd0\x02\x02\
    \x0c\n\r\n\x05\x04\x05\x02\x01\x01\x12\x04\xd0\x02\r\x11\n\r\n\x05\x04\
    \x05\x02\x01\x03\x12\x04\xd0\x02\x14\x15\n\x98\x01\n\x02\x04\x06\x12\x06\
    \xd5\x02\0\xda\x02\x01\x1a\x89\x01\x20Request\x20message\x20for\n\x20[go\
    ogle.bigtable.admin.v2.BigtableTableAdmin.DeleteTable][google.bigtable.a\
    dmin.v2.BigtableTableAdmin.DeleteTable]\n\n\x0b\n\x03\x04\x06\x01\x12\
    \x04\xd5\x02\x08\x1a\n\x8f\x01\n\x04\x04\x06\x02\0\x12\x04\xd9\x02\x02\
    \x12\x1a\x80\x01\x20The\x20unique\x20name\x20of\x20the\x20table\x20to\
    \x20be\x20deleted.\n\x20Values\x20are\x20of\x20the\x20form\n\x20`project\
    s/<project>/instances/<instance>/tables/<table>`.\n\n\r\n\x05\x04\x06\
    \x02\0\x05\x12\x04\xd9\x02\x02\x08\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\
    \xd9\x02\t\r\n\r\n\x05\x04\x06\x02\0\x03\x12\x04\xd9\x02\x10\x11\n\xaa\
    \x01\n\x02\x04\x07\x12\x06\xde\x02\0\xfe\x02\x01\x1a\x9b\x01\x20Request\
    \x20message\x20for\n\x20[google.bigtable.admin.v2.BigtableTableAdmin.Mod\
    ifyColumnFamilies][google.bigtable.admin.v2.BigtableTableAdmin.ModifyCol\
    umnFamilies]\n\n\x0b\n\x03\x04\x07\x01\x12\x04\xde\x02\x08#\nL\n\x04\x04\
    \x07\x03\0\x12\x06\xe0\x02\x02\xf2\x02\x03\x1a<\x20A\x20create,\x20updat\
    e,\x20or\x20delete\x20of\x20a\x20particular\x20column\x20family.\n\n\r\n\
    \x05\x04\x07\x03\0\x01\x12\x04\xe0\x02\n\x16\n=\n\x06\x04\x07\x03\0\x02\
    \0\x12\x04\xe2\x02\x04\x12\x1a-\x20The\x20ID\x20of\x20the\x20column\x20f\
    amily\x20to\x20be\x20modified.\n\n\x0f\n\x07\x04\x07\x03\0\x02\0\x05\x12\
    \x04\xe2\x02\x04\n\n\x0f\n\x07\x04\x07\x03\0\x02\0\x01\x12\x04\xe2\x02\
    \x0b\r\n\x0f\n\x07\x04\x07\x03\0\x02\0\x03\x12\x04\xe2\x02\x10\x11\n1\n\
    \x06\x04\x07\x03\0\x08\0\x12\x06\xe5\x02\x04\xf1\x02\x05\x1a\x1f\x20Colu\
    mn\x20familiy\x20modifications.\n\n\x0f\n\x07\x04\x07\x03\0\x08\0\x01\
    \x12\x04\xe5\x02\n\r\ny\n\x06\x04\x07\x03\0\x02\x01\x12\x04\xe8\x02\x06\
    \x1e\x1ai\x20Create\x20a\x20new\x20column\x20family\x20with\x20the\x20sp\
    ecified\x20schema,\x20or\x20fail\x20if\n\x20one\x20already\x20exists\x20\
    with\x20the\x20given\x20ID.\n\n\x0f\n\x07\x04\x07\x03\0\x02\x01\x06\x12\
    \x04\xe8\x02\x06\x12\n\x0f\n\x07\x04\x07\x03\0\x02\x01\x01\x12\x04\xe8\
    \x02\x13\x19\n\x0f\n\x07\x04\x07\x03\0\x02\x01\x03\x12\x04\xe8\x02\x1c\
    \x1d\n\x82\x01\n\x06\x04\x07\x03\0\x02\x02\x12\x04\xec\x02\x06\x1e\x1ar\
    \x20Update\x20an\x20existing\x20column\x20family\x20to\x20the\x20specifi\
    ed\x20schema,\x20or\x20fail\n\x20if\x20no\x20column\x20family\x20exists\
    \x20with\x20the\x20given\x20ID.\n\n\x0f\n\x07\x04\x07\x03\0\x02\x02\x06\
    \x12\x04\xec\x02\x06\x12\n\x0f\n\x07\x04\x07\x03\0\x02\x02\x01\x12\x04\
    \xec\x02\x13\x19\n\x0f\n\x07\x04\x07\x03\0\x02\x02\x03\x12\x04\xec\x02\
    \x1c\x1d\ng\n\x06\x04\x07\x03\0\x02\x03\x12\x04\xf0\x02\x06\x14\x1aW\x20\
    Drop\x20(delete)\x20the\x20column\x20family\x20with\x20the\x20given\x20I\
    D,\x20or\x20fail\x20if\x20no\x20such\n\x20family\x20exists.\n\n\x0f\n\
    \x07\x04\x07\x03\0\x02\x03\x05\x12\x04\xf0\x02\x06\n\n\x0f\n\x07\x04\x07\
    \x03\0\x02\x03\x01\x12\x04\xf0\x02\x0b\x0f\n\x0f\n\x07\x04\x07\x03\0\x02\
    \x03\x03\x12\x04\xf0\x02\x12\x13\n\xa3\x01\n\x04\x04\x07\x02\0\x12\x04\
    \xf7\x02\x02\x12\x1a\x94\x01\x20The\x20unique\x20name\x20of\x20the\x20ta\
    ble\x20whose\x20families\x20should\x20be\x20modified.\n\x20Values\x20are\
    \x20of\x20the\x20form\n\x20`projects/<project>/instances/<instance>/tabl\
    es/<table>`.\n\n\r\n\x05\x04\x07\x02\0\x05\x12\x04\xf7\x02\x02\x08\n\r\n\
    \x05\x04\x07\x02\0\x01\x12\x04\xf7\x02\t\r\n\r\n\x05\x04\x07\x02\0\x03\
    \x12\x04\xf7\x02\x10\x11\n\xfd\x01\n\x04\x04\x07\x02\x01\x12\x04\xfd\x02\
    \x02*\x1a\xee\x01\x20Modifications\x20to\x20be\x20atomically\x20applied\
    \x20to\x20the\x20specified\x20table's\x20families.\n\x20Entries\x20are\
    \x20applied\x20in\x20order,\x20meaning\x20that\x20earlier\x20modificatio\
    ns\x20can\x20be\n\x20masked\x20by\x20later\x20ones\x20(in\x20the\x20case\
    \x20of\x20repeated\x20updates\x20to\x20the\x20same\x20family,\n\x20for\
    \x20example).\n\n\r\n\x05\x04\x07\x02\x01\x04\x12\x04\xfd\x02\x02\n\n\r\
    \n\x05\x04\x07\x02\x01\x06\x12\x04\xfd\x02\x0b\x17\n\r\n\x05\x04\x07\x02\
    \x01\x01\x12\x04\xfd\x02\x18%\n\r\n\x05\x04\x07\x02\x01\x03\x12\x04\xfd\
    \x02()\n\xb2\x01\n\x02\x04\x08\x12\x06\x82\x03\0\x87\x03\x01\x1a\xa3\x01\
    \x20Request\x20message\x20for\n\x20[google.bigtable.admin.v2.BigtableTab\
    leAdmin.GenerateConsistencyToken][google.bigtable.admin.v2.BigtableTable\
    Admin.GenerateConsistencyToken]\n\n\x0b\n\x03\x04\x08\x01\x12\x04\x82\
    \x03\x08'\n\xa9\x01\n\x04\x04\x08\x02\0\x12\x04\x86\x03\x02\x12\x1a\x9a\
    \x01\x20The\x20unique\x20name\x20of\x20the\x20Table\x20for\x20which\x20t\
    o\x20create\x20a\x20consistency\x20token.\n\x20Values\x20are\x20of\x20th\
    e\x20form\n\x20`projects/<project>/instances/<instance>/tables/<table>`.\
    \n\n\r\n\x05\x04\x08\x02\0\x05\x12\x04\x86\x03\x02\x08\n\r\n\x05\x04\x08\
    \x02\0\x01\x12\x04\x86\x03\t\r\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\x86\
    \x03\x10\x11\n\xb3\x01\n\x02\x04\t\x12\x06\x8b\x03\0\x8e\x03\x01\x1a\xa4\
    \x01\x20Response\x20message\x20for\n\x20[google.bigtable.admin.v2.Bigtab\
    leTableAdmin.GenerateConsistencyToken][google.bigtable.admin.v2.Bigtable\
    TableAdmin.GenerateConsistencyToken]\n\n\x0b\n\x03\x04\t\x01\x12\x04\x8b\
    \x03\x08(\n0\n\x04\x04\t\x02\0\x12\x04\x8d\x03\x02\x1f\x1a\"\x20The\x20g\
    enerated\x20consistency\x20token.\n\n\r\n\x05\x04\t\x02\0\x05\x12\x04\
    \x8d\x03\x02\x08\n\r\n\x05\x04\t\x02\0\x01\x12\x04\x8d\x03\t\x1a\n\r\n\
    \x05\x04\t\x02\0\x03\x12\x04\x8d\x03\x1d\x1e\n\xa2\x01\n\x02\x04\n\x12\
    \x06\x92\x03\0\x9a\x03\x01\x1a\x93\x01\x20Request\x20message\x20for\n\
    \x20[google.bigtable.admin.v2.BigtableTableAdmin.CheckConsistency][googl\
    e.bigtable.admin.v2.BigtableTableAdmin.CheckConsistency]\n\n\x0b\n\x03\
    \x04\n\x01\x12\x04\x92\x03\x08\x1f\n\xac\x01\n\x04\x04\n\x02\0\x12\x04\
    \x96\x03\x02\x12\x1a\x9d\x01\x20The\x20unique\x20name\x20of\x20the\x20Ta\
    ble\x20for\x20which\x20to\x20check\x20replication\x20consistency.\n\x20V\
    alues\x20are\x20of\x20the\x20form\n\x20`projects/<project>/instances/<in\
    stance>/tables/<table>`.\n\n\r\n\x05\x04\n\x02\0\x05\x12\x04\x96\x03\x02\
    \x08\n\r\n\x05\x04\n\x02\0\x01\x12\x04\x96\x03\t\r\n\r\n\x05\x04\n\x02\0\
    \x03\x12\x04\x96\x03\x10\x11\nO\n\x04\x04\n\x02\x01\x12\x04\x99\x03\x02\
    \x1f\x1aA\x20The\x20token\x20created\x20using\x20GenerateConsistencyToke\
    n\x20for\x20the\x20Table.\n\n\r\n\x05\x04\n\x02\x01\x05\x12\x04\x99\x03\
    \x02\x08\n\r\n\x05\x04\n\x02\x01\x01\x12\x04\x99\x03\t\x1a\n\r\n\x05\x04\
    \n\x02\x01\x03\x12\x04\x99\x03\x1d\x1e\n\xa3\x01\n\x02\x04\x0b\x12\x06\
    \x9e\x03\0\xa2\x03\x01\x1a\x94\x01\x20Response\x20message\x20for\n\x20[g\
    oogle.bigtable.admin.v2.BigtableTableAdmin.CheckConsistency][google.bigt\
    able.admin.v2.BigtableTableAdmin.CheckConsistency]\n\n\x0b\n\x03\x04\x0b\
    \x01\x12\x04\x9e\x03\x08\x20\n\x9a\x01\n\x04\x04\x0b\x02\0\x12\x04\xa1\
    \x03\x02\x16\x1a\x8b\x01\x20True\x20only\x20if\x20the\x20token\x20is\x20\
    consistent.\x20A\x20token\x20is\x20consistent\x20if\x20replication\n\x20\
    has\x20caught\x20up\x20with\x20the\x20restrictions\x20specified\x20in\
    \x20the\x20request.\n\n\r\n\x05\x04\x0b\x02\0\x05\x12\x04\xa1\x03\x02\
    \x06\n\r\n\x05\x04\x0b\x02\0\x01\x12\x04\xa1\x03\x07\x11\n\r\n\x05\x04\
    \x0b\x02\0\x03\x12\x04\xa1\x03\x14\x15\n\xc9\x03\n\x02\x04\x0c\x12\x06\
    \xab\x03\0\xc4\x03\x01\x1a\xba\x03\x20Request\x20message\x20for\n\x20[go\
    ogle.bigtable.admin.v2.BigtableTableAdmin.SnapshotTable][google.bigtable\
    .admin.v2.BigtableTableAdmin.SnapshotTable]\n\n\x20Note:\x20This\x20is\
    \x20a\x20private\x20alpha\x20release\x20of\x20Cloud\x20Bigtable\x20snaps\
    hots.\x20This\n\x20feature\x20is\x20not\x20currently\x20available\x20to\
    \x20most\x20Cloud\x20Bigtable\x20customers.\x20This\n\x20feature\x20migh\
    t\x20be\x20changed\x20in\x20backward-incompatible\x20ways\x20and\x20is\
    \x20not\x20recommended\n\x20for\x20production\x20use.\x20It\x20is\x20not\
    \x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.\n\n\x0b\
    \n\x03\x04\x0c\x01\x12\x04\xab\x03\x08\x1c\n\x9c\x01\n\x04\x04\x0c\x02\0\
    \x12\x04\xaf\x03\x02\x12\x1a\x8d\x01\x20The\x20unique\x20name\x20of\x20t\
    he\x20table\x20to\x20have\x20the\x20snapshot\x20taken.\n\x20Values\x20ar\
    e\x20of\x20the\x20form\n\x20`projects/<project>/instances/<instance>/tab\
    les/<table>`.\n\n\r\n\x05\x04\x0c\x02\0\x05\x12\x04\xaf\x03\x02\x08\n\r\
    \n\x05\x04\x0c\x02\0\x01\x12\x04\xaf\x03\t\r\n\r\n\x05\x04\x0c\x02\0\x03\
    \x12\x04\xaf\x03\x10\x11\n\xa6\x01\n\x04\x04\x0c\x02\x01\x12\x04\xb4\x03\
    \x02\x15\x1a\x97\x01\x20The\x20name\x20of\x20the\x20cluster\x20where\x20\
    the\x20snapshot\x20will\x20be\x20created\x20in.\n\x20Values\x20are\x20of\
    \x20the\x20form\n\x20`projects/<project>/instances/<instance>/clusters/<\
    cluster>`.\n\n\r\n\x05\x04\x0c\x02\x01\x05\x12\x04\xb4\x03\x02\x08\n\r\n\
    \x05\x04\x0c\x02\x01\x01\x12\x04\xb4\x03\t\x10\n\r\n\x05\x04\x0c\x02\x01\
    \x03\x12\x04\xb4\x03\x13\x14\n\x82\x02\n\x04\x04\x0c\x02\x02\x12\x04\xba\
    \x03\x02\x19\x1a\xf3\x01\x20The\x20ID\x20by\x20which\x20the\x20new\x20sn\
    apshot\x20should\x20be\x20referred\x20to\x20within\x20the\x20parent\n\
    \x20cluster,\x20e.g.,\x20`mysnapshot`\x20of\x20the\x20form:\x20`[_a-zA-Z\
    0-9][-_.a-zA-Z0-9]*`\n\x20rather\x20than\n\x20`projects/<project>/instan\
    ces/<instance>/clusters/<cluster>/snapshots/mysnapshot`.\n\n\r\n\x05\x04\
    \x0c\x02\x02\x05\x12\x04\xba\x03\x02\x08\n\r\n\x05\x04\x0c\x02\x02\x01\
    \x12\x04\xba\x03\t\x14\n\r\n\x05\x04\x0c\x02\x02\x03\x12\x04\xba\x03\x17\
    \x18\n\x9c\x02\n\x04\x04\x0c\x02\x03\x12\x04\xc0\x03\x02#\x1a\x8d\x02\
    \x20The\x20amount\x20of\x20time\x20that\x20the\x20new\x20snapshot\x20can\
    \x20stay\x20active\x20after\x20it\x20is\n\x20created.\x20Once\x20'ttl'\
    \x20expires,\x20the\x20snapshot\x20will\x20get\x20deleted.\x20The\x20max\
    imum\n\x20amount\x20of\x20time\x20a\x20snapshot\x20can\x20stay\x20active\
    \x20is\x207\x20days.\x20If\x20'ttl'\x20is\x20not\n\x20specified,\x20the\
    \x20default\x20value\x20of\x2024\x20hours\x20will\x20be\x20used.\n\n\r\n\
    \x05\x04\x0c\x02\x03\x06\x12\x04\xc0\x03\x02\x1a\n\r\n\x05\x04\x0c\x02\
    \x03\x01\x12\x04\xc0\x03\x1b\x1e\n\r\n\x05\x04\x0c\x02\x03\x03\x12\x04\
    \xc0\x03!\"\n,\n\x04\x04\x0c\x02\x04\x12\x04\xc3\x03\x02\x19\x1a\x1e\x20\
    Description\x20of\x20the\x20snapshot.\n\n\r\n\x05\x04\x0c\x02\x04\x05\
    \x12\x04\xc3\x03\x02\x08\n\r\n\x05\x04\x0c\x02\x04\x01\x12\x04\xc3\x03\t\
    \x14\n\r\n\x05\x04\x0c\x02\x04\x03\x12\x04\xc3\x03\x17\x18\n\xc5\x03\n\
    \x02\x04\r\x12\x06\xcd\x03\0\xd2\x03\x01\x1a\xb6\x03\x20Request\x20messa\
    ge\x20for\n\x20[google.bigtable.admin.v2.BigtableTableAdmin.GetSnapshot]\
    [google.bigtable.admin.v2.BigtableTableAdmin.GetSnapshot]\n\n\x20Note:\
    \x20This\x20is\x20a\x20private\x20alpha\x20release\x20of\x20Cloud\x20Big\
    table\x20snapshots.\x20This\n\x20feature\x20is\x20not\x20currently\x20av\
    ailable\x20to\x20most\x20Cloud\x20Bigtable\x20customers.\x20This\n\x20fe\
    ature\x20might\x20be\x20changed\x20in\x20backward-incompatible\x20ways\
    \x20and\x20is\x20not\x20recommended\n\x20for\x20production\x20use.\x20It\
    \x20is\x20not\x20subject\x20to\x20any\x20SLA\x20or\x20deprecation\x20pol\
    icy.\n\n\x0b\n\x03\x04\r\x01\x12\x04\xcd\x03\x08\x1a\n\xa7\x01\n\x04\x04\
    \r\x02\0\x12\x04\xd1\x03\x02\x12\x1a\x98\x01\x20The\x20unique\x20name\
    \x20of\x20the\x20requested\x20snapshot.\n\x20Values\x20are\x20of\x20the\
    \x20form\n\x20`projects/<project>/instances/<instance>/clusters/<cluster\
    >/snapshots/<snapshot>`.\n\n\r\n\x05\x04\r\x02\0\x05\x12\x04\xd1\x03\x02\
    \x08\n\r\n\x05\x04\r\x02\0\x01\x12\x04\xd1\x03\t\r\n\r\n\x05\x04\r\x02\0\
    \x03\x12\x04\xd1\x03\x10\x11\n\xc9\x03\n\x02\x04\x0e\x12\x06\xdb\x03\0\
    \xe9\x03\x01\x1a\xba\x03\x20Request\x20message\x20for\n\x20[google.bigta\
    ble.admin.v2.BigtableTableAdmin.ListSnapshots][google.bigtable.admin.v2.\
    BigtableTableAdmin.ListSnapshots]\n\n\x20Note:\x20This\x20is\x20a\x20pri\
    vate\x20alpha\x20release\x20of\x20Cloud\x20Bigtable\x20snapshots.\x20Thi\
    s\n\x20feature\x20is\x20not\x20currently\x20available\x20to\x20most\x20C\
    loud\x20Bigtable\x20customers.\x20This\n\x20feature\x20might\x20be\x20ch\
    anged\x20in\x20backward-incompatible\x20ways\x20and\x20is\x20not\x20reco\
    mmended\n\x20for\x20production\x20use.\x20It\x20is\x20not\x20subject\x20\
    to\x20any\x20SLA\x20or\x20deprecation\x20policy.\n\n\x0b\n\x03\x04\x0e\
    \x01\x12\x04\xdb\x03\x08\x1c\n\xb3\x02\n\x04\x04\x0e\x02\0\x12\x04\xe1\
    \x03\x02\x14\x1a\xa4\x02\x20The\x20unique\x20name\x20of\x20the\x20cluste\
    r\x20for\x20which\x20snapshots\x20should\x20be\x20listed.\n\x20Values\
    \x20are\x20of\x20the\x20form\n\x20`projects/<project>/instances/<instanc\
    e>/clusters/<cluster>`.\n\x20Use\x20`<cluster>\x20=\x20'-'`\x20to\x20lis\
    t\x20snapshots\x20for\x20all\x20clusters\x20in\x20an\x20instance,\n\x20e\
    .g.,\x20`projects/<project>/instances/<instance>/clusters/-`.\n\n\r\n\
    \x05\x04\x0e\x02\0\x05\x12\x04\xe1\x03\x02\x08\n\r\n\x05\x04\x0e\x02\0\
    \x01\x12\x04\xe1\x03\t\x0f\n\r\n\x05\x04\x0e\x02\0\x03\x12\x04\xe1\x03\
    \x12\x13\ni\n\x04\x04\x0e\x02\x01\x12\x04\xe5\x03\x02\x16\x1a[\x20The\
    \x20maximum\x20number\x20of\x20snapshots\x20to\x20return\x20per\x20page.\
    \n\x20CURRENTLY\x20UNIMPLEMENTED\x20AND\x20IGNORED.\n\n\r\n\x05\x04\x0e\
    \x02\x01\x05\x12\x04\xe5\x03\x02\x07\n\r\n\x05\x04\x0e\x02\x01\x01\x12\
    \x04\xe5\x03\x08\x11\n\r\n\x05\x04\x0e\x02\x01\x03\x12\x04\xe5\x03\x14\
    \x15\nK\n\x04\x04\x0e\x02\x02\x12\x04\xe8\x03\x02\x18\x1a=\x20The\x20val\
    ue\x20of\x20`next_page_token`\x20returned\x20by\x20a\x20previous\x20call\
    .\n\n\r\n\x05\x04\x0e\x02\x02\x05\x12\x04\xe8\x03\x02\x08\n\r\n\x05\x04\
    \x0e\x02\x02\x01\x12\x04\xe8\x03\t\x13\n\r\n\x05\x04\x0e\x02\x02\x03\x12\
    \x04\xe8\x03\x16\x17\n\xca\x03\n\x02\x04\x0f\x12\x06\xf2\x03\0\xfa\x03\
    \x01\x1a\xbb\x03\x20Response\x20message\x20for\n\x20[google.bigtable.adm\
    in.v2.BigtableTableAdmin.ListSnapshots][google.bigtable.admin.v2.Bigtabl\
    eTableAdmin.ListSnapshots]\n\n\x20Note:\x20This\x20is\x20a\x20private\
    \x20alpha\x20release\x20of\x20Cloud\x20Bigtable\x20snapshots.\x20This\n\
    \x20feature\x20is\x20not\x20currently\x20available\x20to\x20most\x20Clou\
    d\x20Bigtable\x20customers.\x20This\n\x20feature\x20might\x20be\x20chang\
    ed\x20in\x20backward-incompatible\x20ways\x20and\x20is\x20not\x20recomme\
    nded\n\x20for\x20production\x20use.\x20It\x20is\x20not\x20subject\x20to\
    \x20any\x20SLA\x20or\x20deprecation\x20policy.\n\n\x0b\n\x03\x04\x0f\x01\
    \x12\x04\xf2\x03\x08\x1d\n?\n\x04\x04\x0f\x02\0\x12\x04\xf4\x03\x02\"\
    \x1a1\x20The\x20snapshots\x20present\x20in\x20the\x20requested\x20cluste\
    r.\n\n\r\n\x05\x04\x0f\x02\0\x04\x12\x04\xf4\x03\x02\n\n\r\n\x05\x04\x0f\
    \x02\0\x06\x12\x04\xf4\x03\x0b\x13\n\r\n\x05\x04\x0f\x02\0\x01\x12\x04\
    \xf4\x03\x14\x1d\n\r\n\x05\x04\x0f\x02\0\x03\x12\x04\xf4\x03\x20!\n\xa7\
    \x01\n\x04\x04\x0f\x02\x01\x12\x04\xf9\x03\x02\x1d\x1a\x98\x01\x20Set\
    \x20if\x20not\x20all\x20snapshots\x20could\x20be\x20returned\x20in\x20a\
    \x20single\x20response.\n\x20Pass\x20this\x20value\x20to\x20`page_token`\
    \x20in\x20another\x20request\x20to\x20get\x20the\x20next\n\x20page\x20of\
    \x20results.\n\n\r\n\x05\x04\x0f\x02\x01\x05\x12\x04\xf9\x03\x02\x08\n\r\
    \n\x05\x04\x0f\x02\x01\x01\x12\x04\xf9\x03\t\x18\n\r\n\x05\x04\x0f\x02\
    \x01\x03\x12\x04\xf9\x03\x1b\x1c\n\xcb\x03\n\x02\x04\x10\x12\x06\x83\x04\
    \0\x88\x04\x01\x1a\xbc\x03\x20Request\x20message\x20for\n\x20[google.big\
    table.admin.v2.BigtableTableAdmin.DeleteSnapshot][google.bigtable.admin.\
    v2.BigtableTableAdmin.DeleteSnapshot]\n\n\x20Note:\x20This\x20is\x20a\
    \x20private\x20alpha\x20release\x20of\x20Cloud\x20Bigtable\x20snapshots.\
    \x20This\n\x20feature\x20is\x20not\x20currently\x20available\x20to\x20mo\
    st\x20Cloud\x20Bigtable\x20customers.\x20This\n\x20feature\x20might\x20b\
    e\x20changed\x20in\x20backward-incompatible\x20ways\x20and\x20is\x20not\
    \x20recommended\n\x20for\x20production\x20use.\x20It\x20is\x20not\x20sub\
    ject\x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.\n\n\x0b\n\x03\
    \x04\x10\x01\x12\x04\x83\x04\x08\x1d\n\xab\x01\n\x04\x04\x10\x02\0\x12\
    \x04\x87\x04\x02\x12\x1a\x9c\x01\x20The\x20unique\x20name\x20of\x20the\
    \x20snapshot\x20to\x20be\x20deleted.\n\x20Values\x20are\x20of\x20the\x20\
    form\n\x20`projects/<project>/instances/<instance>/clusters/<cluster>/sn\
    apshots/<snapshot>`.\n\n\r\n\x05\x04\x10\x02\0\x05\x12\x04\x87\x04\x02\
    \x08\n\r\n\x05\x04\x10\x02\0\x01\x12\x04\x87\x04\t\r\n\r\n\x05\x04\x10\
    \x02\0\x03\x12\x04\x87\x04\x10\x11\n\xf7\x02\n\x02\x04\x11\x12\x06\x90\
    \x04\0\x99\x04\x01\x1a\xe8\x02\x20The\x20metadata\x20for\x20the\x20Opera\
    tion\x20returned\x20by\x20SnapshotTable.\n\n\x20Note:\x20This\x20is\x20a\
    \x20private\x20alpha\x20release\x20of\x20Cloud\x20Bigtable\x20snapshots.\
    \x20This\n\x20feature\x20is\x20not\x20currently\x20available\x20to\x20mo\
    st\x20Cloud\x20Bigtable\x20customers.\x20This\n\x20feature\x20might\x20b\
    e\x20changed\x20in\x20backward-incompatible\x20ways\x20and\x20is\x20not\
    \x20recommended\n\x20for\x20production\x20use.\x20It\x20is\x20not\x20sub\
    ject\x20to\x20any\x20SLA\x20or\x20deprecation\x20policy.\n\n\x0b\n\x03\
    \x04\x11\x01\x12\x04\x90\x04\x08\x1d\nY\n\x04\x04\x11\x02\0\x12\x04\x92\
    \x04\x02,\x1aK\x20The\x20request\x20that\x20prompted\x20the\x20initiatio\
    n\x20of\x20this\x20SnapshotTable\x20operation.\n\n\r\n\x05\x04\x11\x02\0\
    \x06\x12\x04\x92\x04\x02\x16\n\r\n\x05\x04\x11\x02\0\x01\x12\x04\x92\x04\
    \x17'\n\r\n\x05\x04\x11\x02\0\x03\x12\x04\x92\x04*+\nD\n\x04\x04\x11\x02\
    \x01\x12\x04\x95\x04\x02-\x1a6\x20The\x20time\x20at\x20which\x20the\x20o\
    riginal\x20request\x20was\x20received.\n\n\r\n\x05\x04\x11\x02\x01\x06\
    \x12\x04\x95\x04\x02\x1b\n\r\n\x05\x04\x11\x02\x01\x01\x12\x04\x95\x04\
    \x1c(\n\r\n\x05\x04\x11\x02\x01\x03\x12\x04\x95\x04+,\nU\n\x04\x04\x11\
    \x02\x02\x12\x04\x98\x04\x02,\x1aG\x20The\x20time\x20at\x20which\x20the\
    \x20operation\x20failed\x20or\x20was\x20completed\x20successfully.\n\n\r\
    \n\x05\x04\x11\x02\x02\x06\x12\x04\x98\x04\x02\x1b\n\r\n\x05\x04\x11\x02\
    \x02\x01\x12\x04\x98\x04\x1c'\n\r\n\x05\x04\x11\x02\x02\x03\x12\x04\x98\
    \x04*+\n\x81\x03\n\x02\x04\x12\x12\x06\xa1\x04\0\xab\x04\x01\x1a\xf2\x02\
    \x20The\x20metadata\x20for\x20the\x20Operation\x20returned\x20by\x20Crea\
    teTableFromSnapshot.\n\n\x20Note:\x20This\x20is\x20a\x20private\x20alpha\
    \x20release\x20of\x20Cloud\x20Bigtable\x20snapshots.\x20This\n\x20featur\
    e\x20is\x20not\x20currently\x20available\x20to\x20most\x20Cloud\x20Bigta\
    ble\x20customers.\x20This\n\x20feature\x20might\x20be\x20changed\x20in\
    \x20backward-incompatible\x20ways\x20and\x20is\x20not\x20recommended\n\
    \x20for\x20production\x20use.\x20It\x20is\x20not\x20subject\x20to\x20any\
    \x20SLA\x20or\x20deprecation\x20policy.\n\n\x0b\n\x03\x04\x12\x01\x12\
    \x04\xa1\x04\x08'\nd\n\x04\x04\x12\x02\0\x12\x04\xa4\x04\x026\x1aV\x20Th\
    e\x20request\x20that\x20prompted\x20the\x20initiation\x20of\x20this\x20C\
    reateTableFromSnapshot\n\x20operation.\n\n\r\n\x05\x04\x12\x02\0\x06\x12\
    \x04\xa4\x04\x02\x20\n\r\n\x05\x04\x12\x02\0\x01\x12\x04\xa4\x04!1\n\r\n\
    \x05\x04\x12\x02\0\x03\x12\x04\xa4\x0445\nD\n\x04\x04\x12\x02\x01\x12\
    \x04\xa7\x04\x02-\x1a6\x20The\x20time\x20at\x20which\x20the\x20original\
    \x20request\x20was\x20received.\n\n\r\n\x05\x04\x12\x02\x01\x06\x12\x04\
    \xa7\x04\x02\x1b\n\r\n\x05\x04\x12\x02\x01\x01\x12\x04\xa7\x04\x1c(\n\r\
    \n\x05\x04\x12\x02\x01\x03\x12\x04\xa7\x04+,\nU\n\x04\x04\x12\x02\x02\
    \x12\x04\xaa\x04\x02,\x1aG\x20The\x20time\x20at\x20which\x20the\x20opera\
    tion\x20failed\x20or\x20was\x20completed\x20successfully.\n\n\r\n\x05\
    \x04\x12\x02\x02\x06\x12\x04\xaa\x04\x02\x1b\n\r\n\x05\x04\x12\x02\x02\
    \x01\x12\x04\xaa\x04\x1c'\n\r\n\x05\x04\x12\x02\x02\x03\x12\x04\xaa\x04*\
    +b\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()
    })
}