Source file src/google.golang.org/genproto/googleapis/bigtable/v2/data.pb.go

Documentation: google.golang.org/genproto/googleapis/bigtable/v2

     1  // Copyright 2024 Google LLC
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  // Code generated by protoc-gen-go. DO NOT EDIT.
    16  // versions:
    17  // 	protoc-gen-go v1.26.0
    18  // 	protoc        v4.24.4
    19  // source: google/bigtable/v2/data.proto
    20  
    21  package bigtable
    22  
    23  import (
    24  	reflect "reflect"
    25  	sync "sync"
    26  
    27  	_ "google.golang.org/genproto/googleapis/api/annotations"
    28  	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
    29  	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
    30  )
    31  
    32  const (
    33  	// Verify that this generated code is sufficiently up-to-date.
    34  	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
    35  	// Verify that runtime/protoimpl is sufficiently up-to-date.
    36  	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
    37  )
    38  
    39  // Specifies the complete (requested) contents of a single row of a table.
    40  // Rows which exceed 256MiB in size cannot be read in full.
    41  type Row struct {
    42  	state         protoimpl.MessageState
    43  	sizeCache     protoimpl.SizeCache
    44  	unknownFields protoimpl.UnknownFields
    45  
    46  	// The unique key which identifies this row within its table. This is the same
    47  	// key that's used to identify the row in, for example, a MutateRowRequest.
    48  	// May contain any non-empty byte string up to 4KiB in length.
    49  	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
    50  	// May be empty, but only if the entire row is empty.
    51  	// The mutual ordering of column families is not specified.
    52  	Families []*Family `protobuf:"bytes,2,rep,name=families,proto3" json:"families,omitempty"`
    53  }
    54  
    55  func (x *Row) Reset() {
    56  	*x = Row{}
    57  	if protoimpl.UnsafeEnabled {
    58  		mi := &file_google_bigtable_v2_data_proto_msgTypes[0]
    59  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
    60  		ms.StoreMessageInfo(mi)
    61  	}
    62  }
    63  
    64  func (x *Row) String() string {
    65  	return protoimpl.X.MessageStringOf(x)
    66  }
    67  
    68  func (*Row) ProtoMessage() {}
    69  
    70  func (x *Row) ProtoReflect() protoreflect.Message {
    71  	mi := &file_google_bigtable_v2_data_proto_msgTypes[0]
    72  	if protoimpl.UnsafeEnabled && x != nil {
    73  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
    74  		if ms.LoadMessageInfo() == nil {
    75  			ms.StoreMessageInfo(mi)
    76  		}
    77  		return ms
    78  	}
    79  	return mi.MessageOf(x)
    80  }
    81  
    82  // Deprecated: Use Row.ProtoReflect.Descriptor instead.
    83  func (*Row) Descriptor() ([]byte, []int) {
    84  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{0}
    85  }
    86  
    87  func (x *Row) GetKey() []byte {
    88  	if x != nil {
    89  		return x.Key
    90  	}
    91  	return nil
    92  }
    93  
    94  func (x *Row) GetFamilies() []*Family {
    95  	if x != nil {
    96  		return x.Families
    97  	}
    98  	return nil
    99  }
   100  
   101  // Specifies (some of) the contents of a single row/column family intersection
   102  // of a table.
   103  type Family struct {
   104  	state         protoimpl.MessageState
   105  	sizeCache     protoimpl.SizeCache
   106  	unknownFields protoimpl.UnknownFields
   107  
   108  	// The unique key which identifies this family within its row. This is the
   109  	// same key that's used to identify the family in, for example, a RowFilter
   110  	// which sets its "family_name_regex_filter" field.
   111  	// Must match `[-_.a-zA-Z0-9]+`, except that AggregatingRowProcessors may
   112  	// produce cells in a sentinel family with an empty name.
   113  	// Must be no greater than 64 characters in length.
   114  	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
   115  	// Must not be empty. Sorted in order of increasing "qualifier".
   116  	Columns []*Column `protobuf:"bytes,2,rep,name=columns,proto3" json:"columns,omitempty"`
   117  }
   118  
   119  func (x *Family) Reset() {
   120  	*x = Family{}
   121  	if protoimpl.UnsafeEnabled {
   122  		mi := &file_google_bigtable_v2_data_proto_msgTypes[1]
   123  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   124  		ms.StoreMessageInfo(mi)
   125  	}
   126  }
   127  
   128  func (x *Family) String() string {
   129  	return protoimpl.X.MessageStringOf(x)
   130  }
   131  
   132  func (*Family) ProtoMessage() {}
   133  
   134  func (x *Family) ProtoReflect() protoreflect.Message {
   135  	mi := &file_google_bigtable_v2_data_proto_msgTypes[1]
   136  	if protoimpl.UnsafeEnabled && x != nil {
   137  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   138  		if ms.LoadMessageInfo() == nil {
   139  			ms.StoreMessageInfo(mi)
   140  		}
   141  		return ms
   142  	}
   143  	return mi.MessageOf(x)
   144  }
   145  
   146  // Deprecated: Use Family.ProtoReflect.Descriptor instead.
   147  func (*Family) Descriptor() ([]byte, []int) {
   148  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{1}
   149  }
   150  
   151  func (x *Family) GetName() string {
   152  	if x != nil {
   153  		return x.Name
   154  	}
   155  	return ""
   156  }
   157  
   158  func (x *Family) GetColumns() []*Column {
   159  	if x != nil {
   160  		return x.Columns
   161  	}
   162  	return nil
   163  }
   164  
   165  // Specifies (some of) the contents of a single row/column intersection of a
   166  // table.
   167  type Column struct {
   168  	state         protoimpl.MessageState
   169  	sizeCache     protoimpl.SizeCache
   170  	unknownFields protoimpl.UnknownFields
   171  
   172  	// The unique key which identifies this column within its family. This is the
   173  	// same key that's used to identify the column in, for example, a RowFilter
   174  	// which sets its `column_qualifier_regex_filter` field.
   175  	// May contain any byte string, including the empty string, up to 16kiB in
   176  	// length.
   177  	Qualifier []byte `protobuf:"bytes,1,opt,name=qualifier,proto3" json:"qualifier,omitempty"`
   178  	// Must not be empty. Sorted in order of decreasing "timestamp_micros".
   179  	Cells []*Cell `protobuf:"bytes,2,rep,name=cells,proto3" json:"cells,omitempty"`
   180  }
   181  
   182  func (x *Column) Reset() {
   183  	*x = Column{}
   184  	if protoimpl.UnsafeEnabled {
   185  		mi := &file_google_bigtable_v2_data_proto_msgTypes[2]
   186  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   187  		ms.StoreMessageInfo(mi)
   188  	}
   189  }
   190  
   191  func (x *Column) String() string {
   192  	return protoimpl.X.MessageStringOf(x)
   193  }
   194  
   195  func (*Column) ProtoMessage() {}
   196  
   197  func (x *Column) ProtoReflect() protoreflect.Message {
   198  	mi := &file_google_bigtable_v2_data_proto_msgTypes[2]
   199  	if protoimpl.UnsafeEnabled && x != nil {
   200  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   201  		if ms.LoadMessageInfo() == nil {
   202  			ms.StoreMessageInfo(mi)
   203  		}
   204  		return ms
   205  	}
   206  	return mi.MessageOf(x)
   207  }
   208  
   209  // Deprecated: Use Column.ProtoReflect.Descriptor instead.
   210  func (*Column) Descriptor() ([]byte, []int) {
   211  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{2}
   212  }
   213  
   214  func (x *Column) GetQualifier() []byte {
   215  	if x != nil {
   216  		return x.Qualifier
   217  	}
   218  	return nil
   219  }
   220  
   221  func (x *Column) GetCells() []*Cell {
   222  	if x != nil {
   223  		return x.Cells
   224  	}
   225  	return nil
   226  }
   227  
   228  // Specifies (some of) the contents of a single row/column/timestamp of a table.
   229  type Cell struct {
   230  	state         protoimpl.MessageState
   231  	sizeCache     protoimpl.SizeCache
   232  	unknownFields protoimpl.UnknownFields
   233  
   234  	// The cell's stored timestamp, which also uniquely identifies it within
   235  	// its column.
   236  	// Values are always expressed in microseconds, but individual tables may set
   237  	// a coarser granularity to further restrict the allowed values. For
   238  	// example, a table which specifies millisecond granularity will only allow
   239  	// values of `timestamp_micros` which are multiples of 1000.
   240  	TimestampMicros int64 `protobuf:"varint,1,opt,name=timestamp_micros,json=timestampMicros,proto3" json:"timestamp_micros,omitempty"`
   241  	// The value stored in the cell.
   242  	// May contain any byte string, including the empty string, up to 100MiB in
   243  	// length.
   244  	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
   245  	// Labels applied to the cell by a [RowFilter][google.bigtable.v2.RowFilter].
   246  	Labels []string `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty"`
   247  }
   248  
   249  func (x *Cell) Reset() {
   250  	*x = Cell{}
   251  	if protoimpl.UnsafeEnabled {
   252  		mi := &file_google_bigtable_v2_data_proto_msgTypes[3]
   253  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   254  		ms.StoreMessageInfo(mi)
   255  	}
   256  }
   257  
   258  func (x *Cell) String() string {
   259  	return protoimpl.X.MessageStringOf(x)
   260  }
   261  
   262  func (*Cell) ProtoMessage() {}
   263  
   264  func (x *Cell) ProtoReflect() protoreflect.Message {
   265  	mi := &file_google_bigtable_v2_data_proto_msgTypes[3]
   266  	if protoimpl.UnsafeEnabled && x != nil {
   267  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   268  		if ms.LoadMessageInfo() == nil {
   269  			ms.StoreMessageInfo(mi)
   270  		}
   271  		return ms
   272  	}
   273  	return mi.MessageOf(x)
   274  }
   275  
   276  // Deprecated: Use Cell.ProtoReflect.Descriptor instead.
   277  func (*Cell) Descriptor() ([]byte, []int) {
   278  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{3}
   279  }
   280  
   281  func (x *Cell) GetTimestampMicros() int64 {
   282  	if x != nil {
   283  		return x.TimestampMicros
   284  	}
   285  	return 0
   286  }
   287  
   288  func (x *Cell) GetValue() []byte {
   289  	if x != nil {
   290  		return x.Value
   291  	}
   292  	return nil
   293  }
   294  
   295  func (x *Cell) GetLabels() []string {
   296  	if x != nil {
   297  		return x.Labels
   298  	}
   299  	return nil
   300  }
   301  
   302  // `Value` represents a dynamically typed value.
   303  // The typed fields in `Value` are used as a transport encoding for the actual
   304  // value (which may be of a more complex type). See the documentation of the
   305  // `Type` message for more details.
   306  type Value struct {
   307  	state         protoimpl.MessageState
   308  	sizeCache     protoimpl.SizeCache
   309  	unknownFields protoimpl.UnknownFields
   310  
   311  	// Options for transporting values within the protobuf type system. A given
   312  	// `kind` may support more than one `type` and vice versa. On write, this is
   313  	// roughly analogous to a GoogleSQL literal.
   314  	//
   315  	// The value is `NULL` if none of the fields in `kind` is set. If `type` is
   316  	// also omitted on write, we will infer it based on the schema.
   317  	//
   318  	// Types that are assignable to Kind:
   319  	//
   320  	//	*Value_RawValue
   321  	//	*Value_RawTimestampMicros
   322  	//	*Value_IntValue
   323  	Kind isValue_Kind `protobuf_oneof:"kind"`
   324  }
   325  
   326  func (x *Value) Reset() {
   327  	*x = Value{}
   328  	if protoimpl.UnsafeEnabled {
   329  		mi := &file_google_bigtable_v2_data_proto_msgTypes[4]
   330  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   331  		ms.StoreMessageInfo(mi)
   332  	}
   333  }
   334  
   335  func (x *Value) String() string {
   336  	return protoimpl.X.MessageStringOf(x)
   337  }
   338  
   339  func (*Value) ProtoMessage() {}
   340  
   341  func (x *Value) ProtoReflect() protoreflect.Message {
   342  	mi := &file_google_bigtable_v2_data_proto_msgTypes[4]
   343  	if protoimpl.UnsafeEnabled && x != nil {
   344  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   345  		if ms.LoadMessageInfo() == nil {
   346  			ms.StoreMessageInfo(mi)
   347  		}
   348  		return ms
   349  	}
   350  	return mi.MessageOf(x)
   351  }
   352  
   353  // Deprecated: Use Value.ProtoReflect.Descriptor instead.
   354  func (*Value) Descriptor() ([]byte, []int) {
   355  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{4}
   356  }
   357  
   358  func (m *Value) GetKind() isValue_Kind {
   359  	if m != nil {
   360  		return m.Kind
   361  	}
   362  	return nil
   363  }
   364  
   365  func (x *Value) GetRawValue() []byte {
   366  	if x, ok := x.GetKind().(*Value_RawValue); ok {
   367  		return x.RawValue
   368  	}
   369  	return nil
   370  }
   371  
   372  func (x *Value) GetRawTimestampMicros() int64 {
   373  	if x, ok := x.GetKind().(*Value_RawTimestampMicros); ok {
   374  		return x.RawTimestampMicros
   375  	}
   376  	return 0
   377  }
   378  
   379  func (x *Value) GetIntValue() int64 {
   380  	if x, ok := x.GetKind().(*Value_IntValue); ok {
   381  		return x.IntValue
   382  	}
   383  	return 0
   384  }
   385  
   386  type isValue_Kind interface {
   387  	isValue_Kind()
   388  }
   389  
   390  type Value_RawValue struct {
   391  	// Represents a raw byte sequence with no type information.
   392  	// The `type` field must be omitted.
   393  	RawValue []byte `protobuf:"bytes,8,opt,name=raw_value,json=rawValue,proto3,oneof"`
   394  }
   395  
   396  type Value_RawTimestampMicros struct {
   397  	// Represents a raw cell timestamp with no type information.
   398  	// The `type` field must be omitted.
   399  	RawTimestampMicros int64 `protobuf:"varint,9,opt,name=raw_timestamp_micros,json=rawTimestampMicros,proto3,oneof"`
   400  }
   401  
   402  type Value_IntValue struct {
   403  	// Represents a typed value transported as an integer.
   404  	// Default type for writes: `Int64`
   405  	IntValue int64 `protobuf:"varint,6,opt,name=int_value,json=intValue,proto3,oneof"`
   406  }
   407  
   408  func (*Value_RawValue) isValue_Kind() {}
   409  
   410  func (*Value_RawTimestampMicros) isValue_Kind() {}
   411  
   412  func (*Value_IntValue) isValue_Kind() {}
   413  
   414  // Specifies a contiguous range of rows.
   415  type RowRange struct {
   416  	state         protoimpl.MessageState
   417  	sizeCache     protoimpl.SizeCache
   418  	unknownFields protoimpl.UnknownFields
   419  
   420  	// The row key at which to start the range.
   421  	// If neither field is set, interpreted as the empty string, inclusive.
   422  	//
   423  	// Types that are assignable to StartKey:
   424  	//
   425  	//	*RowRange_StartKeyClosed
   426  	//	*RowRange_StartKeyOpen
   427  	StartKey isRowRange_StartKey `protobuf_oneof:"start_key"`
   428  	// The row key at which to end the range.
   429  	// If neither field is set, interpreted as the infinite row key, exclusive.
   430  	//
   431  	// Types that are assignable to EndKey:
   432  	//
   433  	//	*RowRange_EndKeyOpen
   434  	//	*RowRange_EndKeyClosed
   435  	EndKey isRowRange_EndKey `protobuf_oneof:"end_key"`
   436  }
   437  
   438  func (x *RowRange) Reset() {
   439  	*x = RowRange{}
   440  	if protoimpl.UnsafeEnabled {
   441  		mi := &file_google_bigtable_v2_data_proto_msgTypes[5]
   442  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   443  		ms.StoreMessageInfo(mi)
   444  	}
   445  }
   446  
   447  func (x *RowRange) String() string {
   448  	return protoimpl.X.MessageStringOf(x)
   449  }
   450  
   451  func (*RowRange) ProtoMessage() {}
   452  
   453  func (x *RowRange) ProtoReflect() protoreflect.Message {
   454  	mi := &file_google_bigtable_v2_data_proto_msgTypes[5]
   455  	if protoimpl.UnsafeEnabled && x != nil {
   456  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   457  		if ms.LoadMessageInfo() == nil {
   458  			ms.StoreMessageInfo(mi)
   459  		}
   460  		return ms
   461  	}
   462  	return mi.MessageOf(x)
   463  }
   464  
   465  // Deprecated: Use RowRange.ProtoReflect.Descriptor instead.
   466  func (*RowRange) Descriptor() ([]byte, []int) {
   467  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{5}
   468  }
   469  
   470  func (m *RowRange) GetStartKey() isRowRange_StartKey {
   471  	if m != nil {
   472  		return m.StartKey
   473  	}
   474  	return nil
   475  }
   476  
   477  func (x *RowRange) GetStartKeyClosed() []byte {
   478  	if x, ok := x.GetStartKey().(*RowRange_StartKeyClosed); ok {
   479  		return x.StartKeyClosed
   480  	}
   481  	return nil
   482  }
   483  
   484  func (x *RowRange) GetStartKeyOpen() []byte {
   485  	if x, ok := x.GetStartKey().(*RowRange_StartKeyOpen); ok {
   486  		return x.StartKeyOpen
   487  	}
   488  	return nil
   489  }
   490  
   491  func (m *RowRange) GetEndKey() isRowRange_EndKey {
   492  	if m != nil {
   493  		return m.EndKey
   494  	}
   495  	return nil
   496  }
   497  
   498  func (x *RowRange) GetEndKeyOpen() []byte {
   499  	if x, ok := x.GetEndKey().(*RowRange_EndKeyOpen); ok {
   500  		return x.EndKeyOpen
   501  	}
   502  	return nil
   503  }
   504  
   505  func (x *RowRange) GetEndKeyClosed() []byte {
   506  	if x, ok := x.GetEndKey().(*RowRange_EndKeyClosed); ok {
   507  		return x.EndKeyClosed
   508  	}
   509  	return nil
   510  }
   511  
   512  type isRowRange_StartKey interface {
   513  	isRowRange_StartKey()
   514  }
   515  
   516  type RowRange_StartKeyClosed struct {
   517  	// Used when giving an inclusive lower bound for the range.
   518  	StartKeyClosed []byte `protobuf:"bytes,1,opt,name=start_key_closed,json=startKeyClosed,proto3,oneof"`
   519  }
   520  
   521  type RowRange_StartKeyOpen struct {
   522  	// Used when giving an exclusive lower bound for the range.
   523  	StartKeyOpen []byte `protobuf:"bytes,2,opt,name=start_key_open,json=startKeyOpen,proto3,oneof"`
   524  }
   525  
   526  func (*RowRange_StartKeyClosed) isRowRange_StartKey() {}
   527  
   528  func (*RowRange_StartKeyOpen) isRowRange_StartKey() {}
   529  
   530  type isRowRange_EndKey interface {
   531  	isRowRange_EndKey()
   532  }
   533  
   534  type RowRange_EndKeyOpen struct {
   535  	// Used when giving an exclusive upper bound for the range.
   536  	EndKeyOpen []byte `protobuf:"bytes,3,opt,name=end_key_open,json=endKeyOpen,proto3,oneof"`
   537  }
   538  
   539  type RowRange_EndKeyClosed struct {
   540  	// Used when giving an inclusive upper bound for the range.
   541  	EndKeyClosed []byte `protobuf:"bytes,4,opt,name=end_key_closed,json=endKeyClosed,proto3,oneof"`
   542  }
   543  
   544  func (*RowRange_EndKeyOpen) isRowRange_EndKey() {}
   545  
   546  func (*RowRange_EndKeyClosed) isRowRange_EndKey() {}
   547  
   548  // Specifies a non-contiguous set of rows.
   549  type RowSet struct {
   550  	state         protoimpl.MessageState
   551  	sizeCache     protoimpl.SizeCache
   552  	unknownFields protoimpl.UnknownFields
   553  
   554  	// Single rows included in the set.
   555  	RowKeys [][]byte `protobuf:"bytes,1,rep,name=row_keys,json=rowKeys,proto3" json:"row_keys,omitempty"`
   556  	// Contiguous row ranges included in the set.
   557  	RowRanges []*RowRange `protobuf:"bytes,2,rep,name=row_ranges,json=rowRanges,proto3" json:"row_ranges,omitempty"`
   558  }
   559  
   560  func (x *RowSet) Reset() {
   561  	*x = RowSet{}
   562  	if protoimpl.UnsafeEnabled {
   563  		mi := &file_google_bigtable_v2_data_proto_msgTypes[6]
   564  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   565  		ms.StoreMessageInfo(mi)
   566  	}
   567  }
   568  
   569  func (x *RowSet) String() string {
   570  	return protoimpl.X.MessageStringOf(x)
   571  }
   572  
   573  func (*RowSet) ProtoMessage() {}
   574  
   575  func (x *RowSet) ProtoReflect() protoreflect.Message {
   576  	mi := &file_google_bigtable_v2_data_proto_msgTypes[6]
   577  	if protoimpl.UnsafeEnabled && x != nil {
   578  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   579  		if ms.LoadMessageInfo() == nil {
   580  			ms.StoreMessageInfo(mi)
   581  		}
   582  		return ms
   583  	}
   584  	return mi.MessageOf(x)
   585  }
   586  
   587  // Deprecated: Use RowSet.ProtoReflect.Descriptor instead.
   588  func (*RowSet) Descriptor() ([]byte, []int) {
   589  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{6}
   590  }
   591  
   592  func (x *RowSet) GetRowKeys() [][]byte {
   593  	if x != nil {
   594  		return x.RowKeys
   595  	}
   596  	return nil
   597  }
   598  
   599  func (x *RowSet) GetRowRanges() []*RowRange {
   600  	if x != nil {
   601  		return x.RowRanges
   602  	}
   603  	return nil
   604  }
   605  
   606  // Specifies a contiguous range of columns within a single column family.
   607  // The range spans from <column_family>:<start_qualifier> to
   608  // <column_family>:<end_qualifier>, where both bounds can be either
   609  // inclusive or exclusive.
   610  type ColumnRange struct {
   611  	state         protoimpl.MessageState
   612  	sizeCache     protoimpl.SizeCache
   613  	unknownFields protoimpl.UnknownFields
   614  
   615  	// The name of the column family within which this range falls.
   616  	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
   617  	// The column qualifier at which to start the range (within `column_family`).
   618  	// If neither field is set, interpreted as the empty string, inclusive.
   619  	//
   620  	// Types that are assignable to StartQualifier:
   621  	//
   622  	//	*ColumnRange_StartQualifierClosed
   623  	//	*ColumnRange_StartQualifierOpen
   624  	StartQualifier isColumnRange_StartQualifier `protobuf_oneof:"start_qualifier"`
   625  	// The column qualifier at which to end the range (within `column_family`).
   626  	// If neither field is set, interpreted as the infinite string, exclusive.
   627  	//
   628  	// Types that are assignable to EndQualifier:
   629  	//
   630  	//	*ColumnRange_EndQualifierClosed
   631  	//	*ColumnRange_EndQualifierOpen
   632  	EndQualifier isColumnRange_EndQualifier `protobuf_oneof:"end_qualifier"`
   633  }
   634  
   635  func (x *ColumnRange) Reset() {
   636  	*x = ColumnRange{}
   637  	if protoimpl.UnsafeEnabled {
   638  		mi := &file_google_bigtable_v2_data_proto_msgTypes[7]
   639  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   640  		ms.StoreMessageInfo(mi)
   641  	}
   642  }
   643  
   644  func (x *ColumnRange) String() string {
   645  	return protoimpl.X.MessageStringOf(x)
   646  }
   647  
   648  func (*ColumnRange) ProtoMessage() {}
   649  
   650  func (x *ColumnRange) ProtoReflect() protoreflect.Message {
   651  	mi := &file_google_bigtable_v2_data_proto_msgTypes[7]
   652  	if protoimpl.UnsafeEnabled && x != nil {
   653  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   654  		if ms.LoadMessageInfo() == nil {
   655  			ms.StoreMessageInfo(mi)
   656  		}
   657  		return ms
   658  	}
   659  	return mi.MessageOf(x)
   660  }
   661  
   662  // Deprecated: Use ColumnRange.ProtoReflect.Descriptor instead.
   663  func (*ColumnRange) Descriptor() ([]byte, []int) {
   664  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{7}
   665  }
   666  
   667  func (x *ColumnRange) GetFamilyName() string {
   668  	if x != nil {
   669  		return x.FamilyName
   670  	}
   671  	return ""
   672  }
   673  
   674  func (m *ColumnRange) GetStartQualifier() isColumnRange_StartQualifier {
   675  	if m != nil {
   676  		return m.StartQualifier
   677  	}
   678  	return nil
   679  }
   680  
   681  func (x *ColumnRange) GetStartQualifierClosed() []byte {
   682  	if x, ok := x.GetStartQualifier().(*ColumnRange_StartQualifierClosed); ok {
   683  		return x.StartQualifierClosed
   684  	}
   685  	return nil
   686  }
   687  
   688  func (x *ColumnRange) GetStartQualifierOpen() []byte {
   689  	if x, ok := x.GetStartQualifier().(*ColumnRange_StartQualifierOpen); ok {
   690  		return x.StartQualifierOpen
   691  	}
   692  	return nil
   693  }
   694  
   695  func (m *ColumnRange) GetEndQualifier() isColumnRange_EndQualifier {
   696  	if m != nil {
   697  		return m.EndQualifier
   698  	}
   699  	return nil
   700  }
   701  
   702  func (x *ColumnRange) GetEndQualifierClosed() []byte {
   703  	if x, ok := x.GetEndQualifier().(*ColumnRange_EndQualifierClosed); ok {
   704  		return x.EndQualifierClosed
   705  	}
   706  	return nil
   707  }
   708  
   709  func (x *ColumnRange) GetEndQualifierOpen() []byte {
   710  	if x, ok := x.GetEndQualifier().(*ColumnRange_EndQualifierOpen); ok {
   711  		return x.EndQualifierOpen
   712  	}
   713  	return nil
   714  }
   715  
   716  type isColumnRange_StartQualifier interface {
   717  	isColumnRange_StartQualifier()
   718  }
   719  
   720  type ColumnRange_StartQualifierClosed struct {
   721  	// Used when giving an inclusive lower bound for the range.
   722  	StartQualifierClosed []byte `protobuf:"bytes,2,opt,name=start_qualifier_closed,json=startQualifierClosed,proto3,oneof"`
   723  }
   724  
   725  type ColumnRange_StartQualifierOpen struct {
   726  	// Used when giving an exclusive lower bound for the range.
   727  	StartQualifierOpen []byte `protobuf:"bytes,3,opt,name=start_qualifier_open,json=startQualifierOpen,proto3,oneof"`
   728  }
   729  
   730  func (*ColumnRange_StartQualifierClosed) isColumnRange_StartQualifier() {}
   731  
   732  func (*ColumnRange_StartQualifierOpen) isColumnRange_StartQualifier() {}
   733  
   734  type isColumnRange_EndQualifier interface {
   735  	isColumnRange_EndQualifier()
   736  }
   737  
   738  type ColumnRange_EndQualifierClosed struct {
   739  	// Used when giving an inclusive upper bound for the range.
   740  	EndQualifierClosed []byte `protobuf:"bytes,4,opt,name=end_qualifier_closed,json=endQualifierClosed,proto3,oneof"`
   741  }
   742  
   743  type ColumnRange_EndQualifierOpen struct {
   744  	// Used when giving an exclusive upper bound for the range.
   745  	EndQualifierOpen []byte `protobuf:"bytes,5,opt,name=end_qualifier_open,json=endQualifierOpen,proto3,oneof"`
   746  }
   747  
   748  func (*ColumnRange_EndQualifierClosed) isColumnRange_EndQualifier() {}
   749  
   750  func (*ColumnRange_EndQualifierOpen) isColumnRange_EndQualifier() {}
   751  
   752  // Specified a contiguous range of microsecond timestamps.
   753  type TimestampRange struct {
   754  	state         protoimpl.MessageState
   755  	sizeCache     protoimpl.SizeCache
   756  	unknownFields protoimpl.UnknownFields
   757  
   758  	// Inclusive lower bound. If left empty, interpreted as 0.
   759  	StartTimestampMicros int64 `protobuf:"varint,1,opt,name=start_timestamp_micros,json=startTimestampMicros,proto3" json:"start_timestamp_micros,omitempty"`
   760  	// Exclusive upper bound. If left empty, interpreted as infinity.
   761  	EndTimestampMicros int64 `protobuf:"varint,2,opt,name=end_timestamp_micros,json=endTimestampMicros,proto3" json:"end_timestamp_micros,omitempty"`
   762  }
   763  
   764  func (x *TimestampRange) Reset() {
   765  	*x = TimestampRange{}
   766  	if protoimpl.UnsafeEnabled {
   767  		mi := &file_google_bigtable_v2_data_proto_msgTypes[8]
   768  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   769  		ms.StoreMessageInfo(mi)
   770  	}
   771  }
   772  
   773  func (x *TimestampRange) String() string {
   774  	return protoimpl.X.MessageStringOf(x)
   775  }
   776  
   777  func (*TimestampRange) ProtoMessage() {}
   778  
   779  func (x *TimestampRange) ProtoReflect() protoreflect.Message {
   780  	mi := &file_google_bigtable_v2_data_proto_msgTypes[8]
   781  	if protoimpl.UnsafeEnabled && x != nil {
   782  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   783  		if ms.LoadMessageInfo() == nil {
   784  			ms.StoreMessageInfo(mi)
   785  		}
   786  		return ms
   787  	}
   788  	return mi.MessageOf(x)
   789  }
   790  
   791  // Deprecated: Use TimestampRange.ProtoReflect.Descriptor instead.
   792  func (*TimestampRange) Descriptor() ([]byte, []int) {
   793  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{8}
   794  }
   795  
   796  func (x *TimestampRange) GetStartTimestampMicros() int64 {
   797  	if x != nil {
   798  		return x.StartTimestampMicros
   799  	}
   800  	return 0
   801  }
   802  
   803  func (x *TimestampRange) GetEndTimestampMicros() int64 {
   804  	if x != nil {
   805  		return x.EndTimestampMicros
   806  	}
   807  	return 0
   808  }
   809  
   810  // Specifies a contiguous range of raw byte values.
   811  type ValueRange struct {
   812  	state         protoimpl.MessageState
   813  	sizeCache     protoimpl.SizeCache
   814  	unknownFields protoimpl.UnknownFields
   815  
   816  	// The value at which to start the range.
   817  	// If neither field is set, interpreted as the empty string, inclusive.
   818  	//
   819  	// Types that are assignable to StartValue:
   820  	//
   821  	//	*ValueRange_StartValueClosed
   822  	//	*ValueRange_StartValueOpen
   823  	StartValue isValueRange_StartValue `protobuf_oneof:"start_value"`
   824  	// The value at which to end the range.
   825  	// If neither field is set, interpreted as the infinite string, exclusive.
   826  	//
   827  	// Types that are assignable to EndValue:
   828  	//
   829  	//	*ValueRange_EndValueClosed
   830  	//	*ValueRange_EndValueOpen
   831  	EndValue isValueRange_EndValue `protobuf_oneof:"end_value"`
   832  }
   833  
   834  func (x *ValueRange) Reset() {
   835  	*x = ValueRange{}
   836  	if protoimpl.UnsafeEnabled {
   837  		mi := &file_google_bigtable_v2_data_proto_msgTypes[9]
   838  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   839  		ms.StoreMessageInfo(mi)
   840  	}
   841  }
   842  
   843  func (x *ValueRange) String() string {
   844  	return protoimpl.X.MessageStringOf(x)
   845  }
   846  
   847  func (*ValueRange) ProtoMessage() {}
   848  
   849  func (x *ValueRange) ProtoReflect() protoreflect.Message {
   850  	mi := &file_google_bigtable_v2_data_proto_msgTypes[9]
   851  	if protoimpl.UnsafeEnabled && x != nil {
   852  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   853  		if ms.LoadMessageInfo() == nil {
   854  			ms.StoreMessageInfo(mi)
   855  		}
   856  		return ms
   857  	}
   858  	return mi.MessageOf(x)
   859  }
   860  
   861  // Deprecated: Use ValueRange.ProtoReflect.Descriptor instead.
   862  func (*ValueRange) Descriptor() ([]byte, []int) {
   863  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{9}
   864  }
   865  
   866  func (m *ValueRange) GetStartValue() isValueRange_StartValue {
   867  	if m != nil {
   868  		return m.StartValue
   869  	}
   870  	return nil
   871  }
   872  
   873  func (x *ValueRange) GetStartValueClosed() []byte {
   874  	if x, ok := x.GetStartValue().(*ValueRange_StartValueClosed); ok {
   875  		return x.StartValueClosed
   876  	}
   877  	return nil
   878  }
   879  
   880  func (x *ValueRange) GetStartValueOpen() []byte {
   881  	if x, ok := x.GetStartValue().(*ValueRange_StartValueOpen); ok {
   882  		return x.StartValueOpen
   883  	}
   884  	return nil
   885  }
   886  
   887  func (m *ValueRange) GetEndValue() isValueRange_EndValue {
   888  	if m != nil {
   889  		return m.EndValue
   890  	}
   891  	return nil
   892  }
   893  
   894  func (x *ValueRange) GetEndValueClosed() []byte {
   895  	if x, ok := x.GetEndValue().(*ValueRange_EndValueClosed); ok {
   896  		return x.EndValueClosed
   897  	}
   898  	return nil
   899  }
   900  
   901  func (x *ValueRange) GetEndValueOpen() []byte {
   902  	if x, ok := x.GetEndValue().(*ValueRange_EndValueOpen); ok {
   903  		return x.EndValueOpen
   904  	}
   905  	return nil
   906  }
   907  
   908  type isValueRange_StartValue interface {
   909  	isValueRange_StartValue()
   910  }
   911  
   912  type ValueRange_StartValueClosed struct {
   913  	// Used when giving an inclusive lower bound for the range.
   914  	StartValueClosed []byte `protobuf:"bytes,1,opt,name=start_value_closed,json=startValueClosed,proto3,oneof"`
   915  }
   916  
   917  type ValueRange_StartValueOpen struct {
   918  	// Used when giving an exclusive lower bound for the range.
   919  	StartValueOpen []byte `protobuf:"bytes,2,opt,name=start_value_open,json=startValueOpen,proto3,oneof"`
   920  }
   921  
   922  func (*ValueRange_StartValueClosed) isValueRange_StartValue() {}
   923  
   924  func (*ValueRange_StartValueOpen) isValueRange_StartValue() {}
   925  
   926  type isValueRange_EndValue interface {
   927  	isValueRange_EndValue()
   928  }
   929  
   930  type ValueRange_EndValueClosed struct {
   931  	// Used when giving an inclusive upper bound for the range.
   932  	EndValueClosed []byte `protobuf:"bytes,3,opt,name=end_value_closed,json=endValueClosed,proto3,oneof"`
   933  }
   934  
   935  type ValueRange_EndValueOpen struct {
   936  	// Used when giving an exclusive upper bound for the range.
   937  	EndValueOpen []byte `protobuf:"bytes,4,opt,name=end_value_open,json=endValueOpen,proto3,oneof"`
   938  }
   939  
   940  func (*ValueRange_EndValueClosed) isValueRange_EndValue() {}
   941  
   942  func (*ValueRange_EndValueOpen) isValueRange_EndValue() {}
   943  
   944  // Takes a row as input and produces an alternate view of the row based on
   945  // specified rules. For example, a RowFilter might trim down a row to include
   946  // just the cells from columns matching a given regular expression, or might
   947  // return all the cells of a row but not their values. More complicated filters
   948  // can be composed out of these components to express requests such as, "within
   949  // every column of a particular family, give just the two most recent cells
   950  // which are older than timestamp X."
   951  //
   952  // There are two broad categories of RowFilters (true filters and transformers),
   953  // as well as two ways to compose simple filters into more complex ones
   954  // (chains and interleaves). They work as follows:
   955  //
   956  // * True filters alter the input row by excluding some of its cells wholesale
   957  // from the output row. An example of a true filter is the `value_regex_filter`,
   958  // which excludes cells whose values don't match the specified pattern. All
   959  // regex true filters use RE2 syntax (https://github.com/google/re2/wiki/Syntax)
   960  // in raw byte mode (RE2::Latin1), and are evaluated as full matches. An
   961  // important point to keep in mind is that `RE2(.)` is equivalent by default to
   962  // `RE2([^\n])`, meaning that it does not match newlines. When attempting to
   963  // match an arbitrary byte, you should therefore use the escape sequence `\C`,
   964  // which may need to be further escaped as `\\C` in your client language.
   965  //
   966  // * Transformers alter the input row by changing the values of some of its
   967  // cells in the output, without excluding them completely. Currently, the only
   968  // supported transformer is the `strip_value_transformer`, which replaces every
   969  // cell's value with the empty string.
   970  //
   971  // * Chains and interleaves are described in more detail in the
   972  // RowFilter.Chain and RowFilter.Interleave documentation.
   973  //
   974  // The total serialized size of a RowFilter message must not
   975  // exceed 20480 bytes, and RowFilters may not be nested within each other
   976  // (in Chains or Interleaves) to a depth of more than 20.
   977  type RowFilter struct {
   978  	state         protoimpl.MessageState
   979  	sizeCache     protoimpl.SizeCache
   980  	unknownFields protoimpl.UnknownFields
   981  
   982  	// Which of the possible RowFilter types to apply. If none are set, this
   983  	// RowFilter returns all cells in the input row.
   984  	//
   985  	// Types that are assignable to Filter:
   986  	//
   987  	//	*RowFilter_Chain_
   988  	//	*RowFilter_Interleave_
   989  	//	*RowFilter_Condition_
   990  	//	*RowFilter_Sink
   991  	//	*RowFilter_PassAllFilter
   992  	//	*RowFilter_BlockAllFilter
   993  	//	*RowFilter_RowKeyRegexFilter
   994  	//	*RowFilter_RowSampleFilter
   995  	//	*RowFilter_FamilyNameRegexFilter
   996  	//	*RowFilter_ColumnQualifierRegexFilter
   997  	//	*RowFilter_ColumnRangeFilter
   998  	//	*RowFilter_TimestampRangeFilter
   999  	//	*RowFilter_ValueRegexFilter
  1000  	//	*RowFilter_ValueRangeFilter
  1001  	//	*RowFilter_CellsPerRowOffsetFilter
  1002  	//	*RowFilter_CellsPerRowLimitFilter
  1003  	//	*RowFilter_CellsPerColumnLimitFilter
  1004  	//	*RowFilter_StripValueTransformer
  1005  	//	*RowFilter_ApplyLabelTransformer
  1006  	Filter isRowFilter_Filter `protobuf_oneof:"filter"`
  1007  }
  1008  
  1009  func (x *RowFilter) Reset() {
  1010  	*x = RowFilter{}
  1011  	if protoimpl.UnsafeEnabled {
  1012  		mi := &file_google_bigtable_v2_data_proto_msgTypes[10]
  1013  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1014  		ms.StoreMessageInfo(mi)
  1015  	}
  1016  }
  1017  
  1018  func (x *RowFilter) String() string {
  1019  	return protoimpl.X.MessageStringOf(x)
  1020  }
  1021  
  1022  func (*RowFilter) ProtoMessage() {}
  1023  
  1024  func (x *RowFilter) ProtoReflect() protoreflect.Message {
  1025  	mi := &file_google_bigtable_v2_data_proto_msgTypes[10]
  1026  	if protoimpl.UnsafeEnabled && x != nil {
  1027  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1028  		if ms.LoadMessageInfo() == nil {
  1029  			ms.StoreMessageInfo(mi)
  1030  		}
  1031  		return ms
  1032  	}
  1033  	return mi.MessageOf(x)
  1034  }
  1035  
  1036  // Deprecated: Use RowFilter.ProtoReflect.Descriptor instead.
  1037  func (*RowFilter) Descriptor() ([]byte, []int) {
  1038  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{10}
  1039  }
  1040  
  1041  func (m *RowFilter) GetFilter() isRowFilter_Filter {
  1042  	if m != nil {
  1043  		return m.Filter
  1044  	}
  1045  	return nil
  1046  }
  1047  
  1048  func (x *RowFilter) GetChain() *RowFilter_Chain {
  1049  	if x, ok := x.GetFilter().(*RowFilter_Chain_); ok {
  1050  		return x.Chain
  1051  	}
  1052  	return nil
  1053  }
  1054  
  1055  func (x *RowFilter) GetInterleave() *RowFilter_Interleave {
  1056  	if x, ok := x.GetFilter().(*RowFilter_Interleave_); ok {
  1057  		return x.Interleave
  1058  	}
  1059  	return nil
  1060  }
  1061  
  1062  func (x *RowFilter) GetCondition() *RowFilter_Condition {
  1063  	if x, ok := x.GetFilter().(*RowFilter_Condition_); ok {
  1064  		return x.Condition
  1065  	}
  1066  	return nil
  1067  }
  1068  
  1069  func (x *RowFilter) GetSink() bool {
  1070  	if x, ok := x.GetFilter().(*RowFilter_Sink); ok {
  1071  		return x.Sink
  1072  	}
  1073  	return false
  1074  }
  1075  
  1076  func (x *RowFilter) GetPassAllFilter() bool {
  1077  	if x, ok := x.GetFilter().(*RowFilter_PassAllFilter); ok {
  1078  		return x.PassAllFilter
  1079  	}
  1080  	return false
  1081  }
  1082  
  1083  func (x *RowFilter) GetBlockAllFilter() bool {
  1084  	if x, ok := x.GetFilter().(*RowFilter_BlockAllFilter); ok {
  1085  		return x.BlockAllFilter
  1086  	}
  1087  	return false
  1088  }
  1089  
  1090  func (x *RowFilter) GetRowKeyRegexFilter() []byte {
  1091  	if x, ok := x.GetFilter().(*RowFilter_RowKeyRegexFilter); ok {
  1092  		return x.RowKeyRegexFilter
  1093  	}
  1094  	return nil
  1095  }
  1096  
  1097  func (x *RowFilter) GetRowSampleFilter() float64 {
  1098  	if x, ok := x.GetFilter().(*RowFilter_RowSampleFilter); ok {
  1099  		return x.RowSampleFilter
  1100  	}
  1101  	return 0
  1102  }
  1103  
  1104  func (x *RowFilter) GetFamilyNameRegexFilter() string {
  1105  	if x, ok := x.GetFilter().(*RowFilter_FamilyNameRegexFilter); ok {
  1106  		return x.FamilyNameRegexFilter
  1107  	}
  1108  	return ""
  1109  }
  1110  
  1111  func (x *RowFilter) GetColumnQualifierRegexFilter() []byte {
  1112  	if x, ok := x.GetFilter().(*RowFilter_ColumnQualifierRegexFilter); ok {
  1113  		return x.ColumnQualifierRegexFilter
  1114  	}
  1115  	return nil
  1116  }
  1117  
  1118  func (x *RowFilter) GetColumnRangeFilter() *ColumnRange {
  1119  	if x, ok := x.GetFilter().(*RowFilter_ColumnRangeFilter); ok {
  1120  		return x.ColumnRangeFilter
  1121  	}
  1122  	return nil
  1123  }
  1124  
  1125  func (x *RowFilter) GetTimestampRangeFilter() *TimestampRange {
  1126  	if x, ok := x.GetFilter().(*RowFilter_TimestampRangeFilter); ok {
  1127  		return x.TimestampRangeFilter
  1128  	}
  1129  	return nil
  1130  }
  1131  
  1132  func (x *RowFilter) GetValueRegexFilter() []byte {
  1133  	if x, ok := x.GetFilter().(*RowFilter_ValueRegexFilter); ok {
  1134  		return x.ValueRegexFilter
  1135  	}
  1136  	return nil
  1137  }
  1138  
  1139  func (x *RowFilter) GetValueRangeFilter() *ValueRange {
  1140  	if x, ok := x.GetFilter().(*RowFilter_ValueRangeFilter); ok {
  1141  		return x.ValueRangeFilter
  1142  	}
  1143  	return nil
  1144  }
  1145  
  1146  func (x *RowFilter) GetCellsPerRowOffsetFilter() int32 {
  1147  	if x, ok := x.GetFilter().(*RowFilter_CellsPerRowOffsetFilter); ok {
  1148  		return x.CellsPerRowOffsetFilter
  1149  	}
  1150  	return 0
  1151  }
  1152  
  1153  func (x *RowFilter) GetCellsPerRowLimitFilter() int32 {
  1154  	if x, ok := x.GetFilter().(*RowFilter_CellsPerRowLimitFilter); ok {
  1155  		return x.CellsPerRowLimitFilter
  1156  	}
  1157  	return 0
  1158  }
  1159  
  1160  func (x *RowFilter) GetCellsPerColumnLimitFilter() int32 {
  1161  	if x, ok := x.GetFilter().(*RowFilter_CellsPerColumnLimitFilter); ok {
  1162  		return x.CellsPerColumnLimitFilter
  1163  	}
  1164  	return 0
  1165  }
  1166  
  1167  func (x *RowFilter) GetStripValueTransformer() bool {
  1168  	if x, ok := x.GetFilter().(*RowFilter_StripValueTransformer); ok {
  1169  		return x.StripValueTransformer
  1170  	}
  1171  	return false
  1172  }
  1173  
  1174  func (x *RowFilter) GetApplyLabelTransformer() string {
  1175  	if x, ok := x.GetFilter().(*RowFilter_ApplyLabelTransformer); ok {
  1176  		return x.ApplyLabelTransformer
  1177  	}
  1178  	return ""
  1179  }
  1180  
  1181  type isRowFilter_Filter interface {
  1182  	isRowFilter_Filter()
  1183  }
  1184  
  1185  type RowFilter_Chain_ struct {
  1186  	// Applies several RowFilters to the data in sequence, progressively
  1187  	// narrowing the results.
  1188  	Chain *RowFilter_Chain `protobuf:"bytes,1,opt,name=chain,proto3,oneof"`
  1189  }
  1190  
  1191  type RowFilter_Interleave_ struct {
  1192  	// Applies several RowFilters to the data in parallel and combines the
  1193  	// results.
  1194  	Interleave *RowFilter_Interleave `protobuf:"bytes,2,opt,name=interleave,proto3,oneof"`
  1195  }
  1196  
  1197  type RowFilter_Condition_ struct {
  1198  	// Applies one of two possible RowFilters to the data based on the output of
  1199  	// a predicate RowFilter.
  1200  	Condition *RowFilter_Condition `protobuf:"bytes,3,opt,name=condition,proto3,oneof"`
  1201  }
  1202  
  1203  type RowFilter_Sink struct {
  1204  	// ADVANCED USE ONLY.
  1205  	// Hook for introspection into the RowFilter. Outputs all cells directly to
  1206  	// the output of the read rather than to any parent filter. Consider the
  1207  	// following example:
  1208  	//
  1209  	//	Chain(
  1210  	//	  FamilyRegex("A"),
  1211  	//	  Interleave(
  1212  	//	    All(),
  1213  	//	    Chain(Label("foo"), Sink())
  1214  	//	  ),
  1215  	//	  QualifierRegex("B")
  1216  	//	)
  1217  	//
  1218  	//	                    A,A,1,w
  1219  	//	                    A,B,2,x
  1220  	//	                    B,B,4,z
  1221  	//	                       |
  1222  	//	                FamilyRegex("A")
  1223  	//	                       |
  1224  	//	                    A,A,1,w
  1225  	//	                    A,B,2,x
  1226  	//	                       |
  1227  	//	          +------------+-------------+
  1228  	//	          |                          |
  1229  	//	        All()                    Label(foo)
  1230  	//	          |                          |
  1231  	//	       A,A,1,w              A,A,1,w,labels:[foo]
  1232  	//	       A,B,2,x              A,B,2,x,labels:[foo]
  1233  	//	          |                          |
  1234  	//	          |                        Sink() --------------+
  1235  	//	          |                          |                  |
  1236  	//	          +------------+      x------+          A,A,1,w,labels:[foo]
  1237  	//	                       |                        A,B,2,x,labels:[foo]
  1238  	//	                    A,A,1,w                             |
  1239  	//	                    A,B,2,x                             |
  1240  	//	                       |                                |
  1241  	//	               QualifierRegex("B")                      |
  1242  	//	                       |                                |
  1243  	//	                    A,B,2,x                             |
  1244  	//	                       |                                |
  1245  	//	                       +--------------------------------+
  1246  	//	                       |
  1247  	//	                    A,A,1,w,labels:[foo]
  1248  	//	                    A,B,2,x,labels:[foo]  // could be switched
  1249  	//	                    A,B,2,x               // could be switched
  1250  	//
  1251  	// Despite being excluded by the qualifier filter, a copy of every cell
  1252  	// that reaches the sink is present in the final result.
  1253  	//
  1254  	// As with an [Interleave][google.bigtable.v2.RowFilter.Interleave],
  1255  	// duplicate cells are possible, and appear in an unspecified mutual order.
  1256  	// In this case we have a duplicate with column "A:B" and timestamp 2,
  1257  	// because one copy passed through the all filter while the other was
  1258  	// passed through the label and sink. Note that one copy has label "foo",
  1259  	// while the other does not.
  1260  	//
  1261  	// Cannot be used within the `predicate_filter`, `true_filter`, or
  1262  	// `false_filter` of a [Condition][google.bigtable.v2.RowFilter.Condition].
  1263  	Sink bool `protobuf:"varint,16,opt,name=sink,proto3,oneof"`
  1264  }
  1265  
  1266  type RowFilter_PassAllFilter struct {
  1267  	// Matches all cells, regardless of input. Functionally equivalent to
  1268  	// leaving `filter` unset, but included for completeness.
  1269  	PassAllFilter bool `protobuf:"varint,17,opt,name=pass_all_filter,json=passAllFilter,proto3,oneof"`
  1270  }
  1271  
  1272  type RowFilter_BlockAllFilter struct {
  1273  	// Does not match any cells, regardless of input. Useful for temporarily
  1274  	// disabling just part of a filter.
  1275  	BlockAllFilter bool `protobuf:"varint,18,opt,name=block_all_filter,json=blockAllFilter,proto3,oneof"`
  1276  }
  1277  
  1278  type RowFilter_RowKeyRegexFilter struct {
  1279  	// Matches only cells from rows whose keys satisfy the given RE2 regex. In
  1280  	// other words, passes through the entire row when the key matches, and
  1281  	// otherwise produces an empty row.
  1282  	// Note that, since row keys can contain arbitrary bytes, the `\C` escape
  1283  	// sequence must be used if a true wildcard is desired. The `.` character
  1284  	// will not match the new line character `\n`, which may be present in a
  1285  	// binary key.
  1286  	RowKeyRegexFilter []byte `protobuf:"bytes,4,opt,name=row_key_regex_filter,json=rowKeyRegexFilter,proto3,oneof"`
  1287  }
  1288  
  1289  type RowFilter_RowSampleFilter struct {
  1290  	// Matches all cells from a row with probability p, and matches no cells
  1291  	// from the row with probability 1-p.
  1292  	RowSampleFilter float64 `protobuf:"fixed64,14,opt,name=row_sample_filter,json=rowSampleFilter,proto3,oneof"`
  1293  }
  1294  
  1295  type RowFilter_FamilyNameRegexFilter struct {
  1296  	// Matches only cells from columns whose families satisfy the given RE2
  1297  	// regex. For technical reasons, the regex must not contain the `:`
  1298  	// character, even if it is not being used as a literal.
  1299  	// Note that, since column families cannot contain the new line character
  1300  	// `\n`, it is sufficient to use `.` as a full wildcard when matching
  1301  	// column family names.
  1302  	FamilyNameRegexFilter string `protobuf:"bytes,5,opt,name=family_name_regex_filter,json=familyNameRegexFilter,proto3,oneof"`
  1303  }
  1304  
  1305  type RowFilter_ColumnQualifierRegexFilter struct {
  1306  	// Matches only cells from columns whose qualifiers satisfy the given RE2
  1307  	// regex.
  1308  	// Note that, since column qualifiers can contain arbitrary bytes, the `\C`
  1309  	// escape sequence must be used if a true wildcard is desired. The `.`
  1310  	// character will not match the new line character `\n`, which may be
  1311  	// present in a binary qualifier.
  1312  	ColumnQualifierRegexFilter []byte `protobuf:"bytes,6,opt,name=column_qualifier_regex_filter,json=columnQualifierRegexFilter,proto3,oneof"`
  1313  }
  1314  
  1315  type RowFilter_ColumnRangeFilter struct {
  1316  	// Matches only cells from columns within the given range.
  1317  	ColumnRangeFilter *ColumnRange `protobuf:"bytes,7,opt,name=column_range_filter,json=columnRangeFilter,proto3,oneof"`
  1318  }
  1319  
  1320  type RowFilter_TimestampRangeFilter struct {
  1321  	// Matches only cells with timestamps within the given range.
  1322  	TimestampRangeFilter *TimestampRange `protobuf:"bytes,8,opt,name=timestamp_range_filter,json=timestampRangeFilter,proto3,oneof"`
  1323  }
  1324  
  1325  type RowFilter_ValueRegexFilter struct {
  1326  	// Matches only cells with values that satisfy the given regular expression.
  1327  	// Note that, since cell values can contain arbitrary bytes, the `\C` escape
  1328  	// sequence must be used if a true wildcard is desired. The `.` character
  1329  	// will not match the new line character `\n`, which may be present in a
  1330  	// binary value.
  1331  	ValueRegexFilter []byte `protobuf:"bytes,9,opt,name=value_regex_filter,json=valueRegexFilter,proto3,oneof"`
  1332  }
  1333  
  1334  type RowFilter_ValueRangeFilter struct {
  1335  	// Matches only cells with values that fall within the given range.
  1336  	ValueRangeFilter *ValueRange `protobuf:"bytes,15,opt,name=value_range_filter,json=valueRangeFilter,proto3,oneof"`
  1337  }
  1338  
  1339  type RowFilter_CellsPerRowOffsetFilter struct {
  1340  	// Skips the first N cells of each row, matching all subsequent cells.
  1341  	// If duplicate cells are present, as is possible when using an Interleave,
  1342  	// each copy of the cell is counted separately.
  1343  	CellsPerRowOffsetFilter int32 `protobuf:"varint,10,opt,name=cells_per_row_offset_filter,json=cellsPerRowOffsetFilter,proto3,oneof"`
  1344  }
  1345  
  1346  type RowFilter_CellsPerRowLimitFilter struct {
  1347  	// Matches only the first N cells of each row.
  1348  	// If duplicate cells are present, as is possible when using an Interleave,
  1349  	// each copy of the cell is counted separately.
  1350  	CellsPerRowLimitFilter int32 `protobuf:"varint,11,opt,name=cells_per_row_limit_filter,json=cellsPerRowLimitFilter,proto3,oneof"`
  1351  }
  1352  
  1353  type RowFilter_CellsPerColumnLimitFilter struct {
  1354  	// Matches only the most recent N cells within each column. For example,
  1355  	// if N=2, this filter would match column `foo:bar` at timestamps 10 and 9,
  1356  	// skip all earlier cells in `foo:bar`, and then begin matching again in
  1357  	// column `foo:bar2`.
  1358  	// If duplicate cells are present, as is possible when using an Interleave,
  1359  	// each copy of the cell is counted separately.
  1360  	CellsPerColumnLimitFilter int32 `protobuf:"varint,12,opt,name=cells_per_column_limit_filter,json=cellsPerColumnLimitFilter,proto3,oneof"`
  1361  }
  1362  
  1363  type RowFilter_StripValueTransformer struct {
  1364  	// Replaces each cell's value with the empty string.
  1365  	StripValueTransformer bool `protobuf:"varint,13,opt,name=strip_value_transformer,json=stripValueTransformer,proto3,oneof"`
  1366  }
  1367  
  1368  type RowFilter_ApplyLabelTransformer struct {
  1369  	// Applies the given label to all cells in the output row. This allows
  1370  	// the client to determine which results were produced from which part of
  1371  	// the filter.
  1372  	//
  1373  	// Values must be at most 15 characters in length, and match the RE2
  1374  	// pattern `[a-z0-9\\-]+`
  1375  	//
  1376  	// Due to a technical limitation, it is not currently possible to apply
  1377  	// multiple labels to a cell. As a result, a Chain may have no more than
  1378  	// one sub-filter which contains a `apply_label_transformer`. It is okay for
  1379  	// an Interleave to contain multiple `apply_label_transformers`, as they
  1380  	// will be applied to separate copies of the input. This may be relaxed in
  1381  	// the future.
  1382  	ApplyLabelTransformer string `protobuf:"bytes,19,opt,name=apply_label_transformer,json=applyLabelTransformer,proto3,oneof"`
  1383  }
  1384  
  1385  func (*RowFilter_Chain_) isRowFilter_Filter() {}
  1386  
  1387  func (*RowFilter_Interleave_) isRowFilter_Filter() {}
  1388  
  1389  func (*RowFilter_Condition_) isRowFilter_Filter() {}
  1390  
  1391  func (*RowFilter_Sink) isRowFilter_Filter() {}
  1392  
  1393  func (*RowFilter_PassAllFilter) isRowFilter_Filter() {}
  1394  
  1395  func (*RowFilter_BlockAllFilter) isRowFilter_Filter() {}
  1396  
  1397  func (*RowFilter_RowKeyRegexFilter) isRowFilter_Filter() {}
  1398  
  1399  func (*RowFilter_RowSampleFilter) isRowFilter_Filter() {}
  1400  
  1401  func (*RowFilter_FamilyNameRegexFilter) isRowFilter_Filter() {}
  1402  
  1403  func (*RowFilter_ColumnQualifierRegexFilter) isRowFilter_Filter() {}
  1404  
  1405  func (*RowFilter_ColumnRangeFilter) isRowFilter_Filter() {}
  1406  
  1407  func (*RowFilter_TimestampRangeFilter) isRowFilter_Filter() {}
  1408  
  1409  func (*RowFilter_ValueRegexFilter) isRowFilter_Filter() {}
  1410  
  1411  func (*RowFilter_ValueRangeFilter) isRowFilter_Filter() {}
  1412  
  1413  func (*RowFilter_CellsPerRowOffsetFilter) isRowFilter_Filter() {}
  1414  
  1415  func (*RowFilter_CellsPerRowLimitFilter) isRowFilter_Filter() {}
  1416  
  1417  func (*RowFilter_CellsPerColumnLimitFilter) isRowFilter_Filter() {}
  1418  
  1419  func (*RowFilter_StripValueTransformer) isRowFilter_Filter() {}
  1420  
  1421  func (*RowFilter_ApplyLabelTransformer) isRowFilter_Filter() {}
  1422  
  1423  // Specifies a particular change to be made to the contents of a row.
  1424  type Mutation struct {
  1425  	state         protoimpl.MessageState
  1426  	sizeCache     protoimpl.SizeCache
  1427  	unknownFields protoimpl.UnknownFields
  1428  
  1429  	// Which of the possible Mutation types to apply.
  1430  	//
  1431  	// Types that are assignable to Mutation:
  1432  	//
  1433  	//	*Mutation_SetCell_
  1434  	//	*Mutation_AddToCell_
  1435  	//	*Mutation_DeleteFromColumn_
  1436  	//	*Mutation_DeleteFromFamily_
  1437  	//	*Mutation_DeleteFromRow_
  1438  	Mutation isMutation_Mutation `protobuf_oneof:"mutation"`
  1439  }
  1440  
  1441  func (x *Mutation) Reset() {
  1442  	*x = Mutation{}
  1443  	if protoimpl.UnsafeEnabled {
  1444  		mi := &file_google_bigtable_v2_data_proto_msgTypes[11]
  1445  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1446  		ms.StoreMessageInfo(mi)
  1447  	}
  1448  }
  1449  
  1450  func (x *Mutation) String() string {
  1451  	return protoimpl.X.MessageStringOf(x)
  1452  }
  1453  
  1454  func (*Mutation) ProtoMessage() {}
  1455  
  1456  func (x *Mutation) ProtoReflect() protoreflect.Message {
  1457  	mi := &file_google_bigtable_v2_data_proto_msgTypes[11]
  1458  	if protoimpl.UnsafeEnabled && x != nil {
  1459  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1460  		if ms.LoadMessageInfo() == nil {
  1461  			ms.StoreMessageInfo(mi)
  1462  		}
  1463  		return ms
  1464  	}
  1465  	return mi.MessageOf(x)
  1466  }
  1467  
  1468  // Deprecated: Use Mutation.ProtoReflect.Descriptor instead.
  1469  func (*Mutation) Descriptor() ([]byte, []int) {
  1470  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{11}
  1471  }
  1472  
  1473  func (m *Mutation) GetMutation() isMutation_Mutation {
  1474  	if m != nil {
  1475  		return m.Mutation
  1476  	}
  1477  	return nil
  1478  }
  1479  
  1480  func (x *Mutation) GetSetCell() *Mutation_SetCell {
  1481  	if x, ok := x.GetMutation().(*Mutation_SetCell_); ok {
  1482  		return x.SetCell
  1483  	}
  1484  	return nil
  1485  }
  1486  
  1487  func (x *Mutation) GetAddToCell() *Mutation_AddToCell {
  1488  	if x, ok := x.GetMutation().(*Mutation_AddToCell_); ok {
  1489  		return x.AddToCell
  1490  	}
  1491  	return nil
  1492  }
  1493  
  1494  func (x *Mutation) GetDeleteFromColumn() *Mutation_DeleteFromColumn {
  1495  	if x, ok := x.GetMutation().(*Mutation_DeleteFromColumn_); ok {
  1496  		return x.DeleteFromColumn
  1497  	}
  1498  	return nil
  1499  }
  1500  
  1501  func (x *Mutation) GetDeleteFromFamily() *Mutation_DeleteFromFamily {
  1502  	if x, ok := x.GetMutation().(*Mutation_DeleteFromFamily_); ok {
  1503  		return x.DeleteFromFamily
  1504  	}
  1505  	return nil
  1506  }
  1507  
  1508  func (x *Mutation) GetDeleteFromRow() *Mutation_DeleteFromRow {
  1509  	if x, ok := x.GetMutation().(*Mutation_DeleteFromRow_); ok {
  1510  		return x.DeleteFromRow
  1511  	}
  1512  	return nil
  1513  }
  1514  
  1515  type isMutation_Mutation interface {
  1516  	isMutation_Mutation()
  1517  }
  1518  
  1519  type Mutation_SetCell_ struct {
  1520  	// Set a cell's value.
  1521  	SetCell *Mutation_SetCell `protobuf:"bytes,1,opt,name=set_cell,json=setCell,proto3,oneof"`
  1522  }
  1523  
  1524  type Mutation_AddToCell_ struct {
  1525  	// Incrementally updates an `Aggregate` cell.
  1526  	AddToCell *Mutation_AddToCell `protobuf:"bytes,5,opt,name=add_to_cell,json=addToCell,proto3,oneof"`
  1527  }
  1528  
  1529  type Mutation_DeleteFromColumn_ struct {
  1530  	// Deletes cells from a column.
  1531  	DeleteFromColumn *Mutation_DeleteFromColumn `protobuf:"bytes,2,opt,name=delete_from_column,json=deleteFromColumn,proto3,oneof"`
  1532  }
  1533  
  1534  type Mutation_DeleteFromFamily_ struct {
  1535  	// Deletes cells from a column family.
  1536  	DeleteFromFamily *Mutation_DeleteFromFamily `protobuf:"bytes,3,opt,name=delete_from_family,json=deleteFromFamily,proto3,oneof"`
  1537  }
  1538  
  1539  type Mutation_DeleteFromRow_ struct {
  1540  	// Deletes cells from the entire row.
  1541  	DeleteFromRow *Mutation_DeleteFromRow `protobuf:"bytes,4,opt,name=delete_from_row,json=deleteFromRow,proto3,oneof"`
  1542  }
  1543  
  1544  func (*Mutation_SetCell_) isMutation_Mutation() {}
  1545  
  1546  func (*Mutation_AddToCell_) isMutation_Mutation() {}
  1547  
  1548  func (*Mutation_DeleteFromColumn_) isMutation_Mutation() {}
  1549  
  1550  func (*Mutation_DeleteFromFamily_) isMutation_Mutation() {}
  1551  
  1552  func (*Mutation_DeleteFromRow_) isMutation_Mutation() {}
  1553  
  1554  // Specifies an atomic read/modify/write operation on the latest value of the
  1555  // specified column.
  1556  type ReadModifyWriteRule struct {
  1557  	state         protoimpl.MessageState
  1558  	sizeCache     protoimpl.SizeCache
  1559  	unknownFields protoimpl.UnknownFields
  1560  
  1561  	// The name of the family to which the read/modify/write should be applied.
  1562  	// Must match `[-_.a-zA-Z0-9]+`
  1563  	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
  1564  	// The qualifier of the column to which the read/modify/write should be
  1565  	// applied.
  1566  	// Can be any byte string, including the empty string.
  1567  	ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
  1568  	// The rule used to determine the column's new latest value from its current
  1569  	// latest value.
  1570  	//
  1571  	// Types that are assignable to Rule:
  1572  	//
  1573  	//	*ReadModifyWriteRule_AppendValue
  1574  	//	*ReadModifyWriteRule_IncrementAmount
  1575  	Rule isReadModifyWriteRule_Rule `protobuf_oneof:"rule"`
  1576  }
  1577  
  1578  func (x *ReadModifyWriteRule) Reset() {
  1579  	*x = ReadModifyWriteRule{}
  1580  	if protoimpl.UnsafeEnabled {
  1581  		mi := &file_google_bigtable_v2_data_proto_msgTypes[12]
  1582  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1583  		ms.StoreMessageInfo(mi)
  1584  	}
  1585  }
  1586  
  1587  func (x *ReadModifyWriteRule) String() string {
  1588  	return protoimpl.X.MessageStringOf(x)
  1589  }
  1590  
  1591  func (*ReadModifyWriteRule) ProtoMessage() {}
  1592  
  1593  func (x *ReadModifyWriteRule) ProtoReflect() protoreflect.Message {
  1594  	mi := &file_google_bigtable_v2_data_proto_msgTypes[12]
  1595  	if protoimpl.UnsafeEnabled && x != nil {
  1596  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1597  		if ms.LoadMessageInfo() == nil {
  1598  			ms.StoreMessageInfo(mi)
  1599  		}
  1600  		return ms
  1601  	}
  1602  	return mi.MessageOf(x)
  1603  }
  1604  
  1605  // Deprecated: Use ReadModifyWriteRule.ProtoReflect.Descriptor instead.
  1606  func (*ReadModifyWriteRule) Descriptor() ([]byte, []int) {
  1607  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{12}
  1608  }
  1609  
  1610  func (x *ReadModifyWriteRule) GetFamilyName() string {
  1611  	if x != nil {
  1612  		return x.FamilyName
  1613  	}
  1614  	return ""
  1615  }
  1616  
  1617  func (x *ReadModifyWriteRule) GetColumnQualifier() []byte {
  1618  	if x != nil {
  1619  		return x.ColumnQualifier
  1620  	}
  1621  	return nil
  1622  }
  1623  
  1624  func (m *ReadModifyWriteRule) GetRule() isReadModifyWriteRule_Rule {
  1625  	if m != nil {
  1626  		return m.Rule
  1627  	}
  1628  	return nil
  1629  }
  1630  
  1631  func (x *ReadModifyWriteRule) GetAppendValue() []byte {
  1632  	if x, ok := x.GetRule().(*ReadModifyWriteRule_AppendValue); ok {
  1633  		return x.AppendValue
  1634  	}
  1635  	return nil
  1636  }
  1637  
  1638  func (x *ReadModifyWriteRule) GetIncrementAmount() int64 {
  1639  	if x, ok := x.GetRule().(*ReadModifyWriteRule_IncrementAmount); ok {
  1640  		return x.IncrementAmount
  1641  	}
  1642  	return 0
  1643  }
  1644  
  1645  type isReadModifyWriteRule_Rule interface {
  1646  	isReadModifyWriteRule_Rule()
  1647  }
  1648  
  1649  type ReadModifyWriteRule_AppendValue struct {
  1650  	// Rule specifying that `append_value` be appended to the existing value.
  1651  	// If the targeted cell is unset, it will be treated as containing the
  1652  	// empty string.
  1653  	AppendValue []byte `protobuf:"bytes,3,opt,name=append_value,json=appendValue,proto3,oneof"`
  1654  }
  1655  
  1656  type ReadModifyWriteRule_IncrementAmount struct {
  1657  	// Rule specifying that `increment_amount` be added to the existing value.
  1658  	// If the targeted cell is unset, it will be treated as containing a zero.
  1659  	// Otherwise, the targeted cell must contain an 8-byte value (interpreted
  1660  	// as a 64-bit big-endian signed integer), or the entire request will fail.
  1661  	IncrementAmount int64 `protobuf:"varint,4,opt,name=increment_amount,json=incrementAmount,proto3,oneof"`
  1662  }
  1663  
  1664  func (*ReadModifyWriteRule_AppendValue) isReadModifyWriteRule_Rule() {}
  1665  
  1666  func (*ReadModifyWriteRule_IncrementAmount) isReadModifyWriteRule_Rule() {}
  1667  
  1668  // NOTE: This API is intended to be used by Apache Beam BigtableIO.
  1669  // A partition of a change stream.
  1670  type StreamPartition struct {
  1671  	state         protoimpl.MessageState
  1672  	sizeCache     protoimpl.SizeCache
  1673  	unknownFields protoimpl.UnknownFields
  1674  
  1675  	// The row range covered by this partition and is specified by
  1676  	// [`start_key_closed`, `end_key_open`).
  1677  	RowRange *RowRange `protobuf:"bytes,1,opt,name=row_range,json=rowRange,proto3" json:"row_range,omitempty"`
  1678  }
  1679  
  1680  func (x *StreamPartition) Reset() {
  1681  	*x = StreamPartition{}
  1682  	if protoimpl.UnsafeEnabled {
  1683  		mi := &file_google_bigtable_v2_data_proto_msgTypes[13]
  1684  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1685  		ms.StoreMessageInfo(mi)
  1686  	}
  1687  }
  1688  
  1689  func (x *StreamPartition) String() string {
  1690  	return protoimpl.X.MessageStringOf(x)
  1691  }
  1692  
  1693  func (*StreamPartition) ProtoMessage() {}
  1694  
  1695  func (x *StreamPartition) ProtoReflect() protoreflect.Message {
  1696  	mi := &file_google_bigtable_v2_data_proto_msgTypes[13]
  1697  	if protoimpl.UnsafeEnabled && x != nil {
  1698  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1699  		if ms.LoadMessageInfo() == nil {
  1700  			ms.StoreMessageInfo(mi)
  1701  		}
  1702  		return ms
  1703  	}
  1704  	return mi.MessageOf(x)
  1705  }
  1706  
  1707  // Deprecated: Use StreamPartition.ProtoReflect.Descriptor instead.
  1708  func (*StreamPartition) Descriptor() ([]byte, []int) {
  1709  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{13}
  1710  }
  1711  
  1712  func (x *StreamPartition) GetRowRange() *RowRange {
  1713  	if x != nil {
  1714  		return x.RowRange
  1715  	}
  1716  	return nil
  1717  }
  1718  
  1719  // NOTE: This API is intended to be used by Apache Beam BigtableIO.
  1720  // The information required to continue reading the data from multiple
  1721  // `StreamPartitions` from where a previous read left off.
  1722  type StreamContinuationTokens struct {
  1723  	state         protoimpl.MessageState
  1724  	sizeCache     protoimpl.SizeCache
  1725  	unknownFields protoimpl.UnknownFields
  1726  
  1727  	// List of continuation tokens.
  1728  	Tokens []*StreamContinuationToken `protobuf:"bytes,1,rep,name=tokens,proto3" json:"tokens,omitempty"`
  1729  }
  1730  
  1731  func (x *StreamContinuationTokens) Reset() {
  1732  	*x = StreamContinuationTokens{}
  1733  	if protoimpl.UnsafeEnabled {
  1734  		mi := &file_google_bigtable_v2_data_proto_msgTypes[14]
  1735  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1736  		ms.StoreMessageInfo(mi)
  1737  	}
  1738  }
  1739  
  1740  func (x *StreamContinuationTokens) String() string {
  1741  	return protoimpl.X.MessageStringOf(x)
  1742  }
  1743  
  1744  func (*StreamContinuationTokens) ProtoMessage() {}
  1745  
  1746  func (x *StreamContinuationTokens) ProtoReflect() protoreflect.Message {
  1747  	mi := &file_google_bigtable_v2_data_proto_msgTypes[14]
  1748  	if protoimpl.UnsafeEnabled && x != nil {
  1749  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1750  		if ms.LoadMessageInfo() == nil {
  1751  			ms.StoreMessageInfo(mi)
  1752  		}
  1753  		return ms
  1754  	}
  1755  	return mi.MessageOf(x)
  1756  }
  1757  
  1758  // Deprecated: Use StreamContinuationTokens.ProtoReflect.Descriptor instead.
  1759  func (*StreamContinuationTokens) Descriptor() ([]byte, []int) {
  1760  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{14}
  1761  }
  1762  
  1763  func (x *StreamContinuationTokens) GetTokens() []*StreamContinuationToken {
  1764  	if x != nil {
  1765  		return x.Tokens
  1766  	}
  1767  	return nil
  1768  }
  1769  
  1770  // NOTE: This API is intended to be used by Apache Beam BigtableIO.
  1771  // The information required to continue reading the data from a
  1772  // `StreamPartition` from where a previous read left off.
  1773  type StreamContinuationToken struct {
  1774  	state         protoimpl.MessageState
  1775  	sizeCache     protoimpl.SizeCache
  1776  	unknownFields protoimpl.UnknownFields
  1777  
  1778  	// The partition that this token applies to.
  1779  	Partition *StreamPartition `protobuf:"bytes,1,opt,name=partition,proto3" json:"partition,omitempty"`
  1780  	// An encoded position in the stream to restart reading from.
  1781  	Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
  1782  }
  1783  
  1784  func (x *StreamContinuationToken) Reset() {
  1785  	*x = StreamContinuationToken{}
  1786  	if protoimpl.UnsafeEnabled {
  1787  		mi := &file_google_bigtable_v2_data_proto_msgTypes[15]
  1788  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1789  		ms.StoreMessageInfo(mi)
  1790  	}
  1791  }
  1792  
  1793  func (x *StreamContinuationToken) String() string {
  1794  	return protoimpl.X.MessageStringOf(x)
  1795  }
  1796  
  1797  func (*StreamContinuationToken) ProtoMessage() {}
  1798  
  1799  func (x *StreamContinuationToken) ProtoReflect() protoreflect.Message {
  1800  	mi := &file_google_bigtable_v2_data_proto_msgTypes[15]
  1801  	if protoimpl.UnsafeEnabled && x != nil {
  1802  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1803  		if ms.LoadMessageInfo() == nil {
  1804  			ms.StoreMessageInfo(mi)
  1805  		}
  1806  		return ms
  1807  	}
  1808  	return mi.MessageOf(x)
  1809  }
  1810  
  1811  // Deprecated: Use StreamContinuationToken.ProtoReflect.Descriptor instead.
  1812  func (*StreamContinuationToken) Descriptor() ([]byte, []int) {
  1813  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{15}
  1814  }
  1815  
  1816  func (x *StreamContinuationToken) GetPartition() *StreamPartition {
  1817  	if x != nil {
  1818  		return x.Partition
  1819  	}
  1820  	return nil
  1821  }
  1822  
  1823  func (x *StreamContinuationToken) GetToken() string {
  1824  	if x != nil {
  1825  		return x.Token
  1826  	}
  1827  	return ""
  1828  }
  1829  
  1830  // A RowFilter which sends rows through several RowFilters in sequence.
  1831  type RowFilter_Chain struct {
  1832  	state         protoimpl.MessageState
  1833  	sizeCache     protoimpl.SizeCache
  1834  	unknownFields protoimpl.UnknownFields
  1835  
  1836  	// The elements of "filters" are chained together to process the input row:
  1837  	// in row -> f(0) -> intermediate row -> f(1) -> ... -> f(N) -> out row
  1838  	// The full chain is executed atomically.
  1839  	Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
  1840  }
  1841  
  1842  func (x *RowFilter_Chain) Reset() {
  1843  	*x = RowFilter_Chain{}
  1844  	if protoimpl.UnsafeEnabled {
  1845  		mi := &file_google_bigtable_v2_data_proto_msgTypes[16]
  1846  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1847  		ms.StoreMessageInfo(mi)
  1848  	}
  1849  }
  1850  
  1851  func (x *RowFilter_Chain) String() string {
  1852  	return protoimpl.X.MessageStringOf(x)
  1853  }
  1854  
  1855  func (*RowFilter_Chain) ProtoMessage() {}
  1856  
  1857  func (x *RowFilter_Chain) ProtoReflect() protoreflect.Message {
  1858  	mi := &file_google_bigtable_v2_data_proto_msgTypes[16]
  1859  	if protoimpl.UnsafeEnabled && x != nil {
  1860  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1861  		if ms.LoadMessageInfo() == nil {
  1862  			ms.StoreMessageInfo(mi)
  1863  		}
  1864  		return ms
  1865  	}
  1866  	return mi.MessageOf(x)
  1867  }
  1868  
  1869  // Deprecated: Use RowFilter_Chain.ProtoReflect.Descriptor instead.
  1870  func (*RowFilter_Chain) Descriptor() ([]byte, []int) {
  1871  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{10, 0}
  1872  }
  1873  
  1874  func (x *RowFilter_Chain) GetFilters() []*RowFilter {
  1875  	if x != nil {
  1876  		return x.Filters
  1877  	}
  1878  	return nil
  1879  }
  1880  
  1881  // A RowFilter which sends each row to each of several component
  1882  // RowFilters and interleaves the results.
  1883  type RowFilter_Interleave struct {
  1884  	state         protoimpl.MessageState
  1885  	sizeCache     protoimpl.SizeCache
  1886  	unknownFields protoimpl.UnknownFields
  1887  
  1888  	// The elements of "filters" all process a copy of the input row, and the
  1889  	// results are pooled, sorted, and combined into a single output row.
  1890  	// If multiple cells are produced with the same column and timestamp,
  1891  	// they will all appear in the output row in an unspecified mutual order.
  1892  	// Consider the following example, with three filters:
  1893  	//
  1894  	//	                             input row
  1895  	//	                                 |
  1896  	//	       -----------------------------------------------------
  1897  	//	       |                         |                         |
  1898  	//	      f(0)                      f(1)                      f(2)
  1899  	//	       |                         |                         |
  1900  	//	1: foo,bar,10,x             foo,bar,10,z              far,bar,7,a
  1901  	//	2: foo,blah,11,z            far,blah,5,x              far,blah,5,x
  1902  	//	       |                         |                         |
  1903  	//	       -----------------------------------------------------
  1904  	//	                                 |
  1905  	//	1:                      foo,bar,10,z   // could have switched with #2
  1906  	//	2:                      foo,bar,10,x   // could have switched with #1
  1907  	//	3:                      foo,blah,11,z
  1908  	//	4:                      far,bar,7,a
  1909  	//	5:                      far,blah,5,x   // identical to #6
  1910  	//	6:                      far,blah,5,x   // identical to #5
  1911  	//
  1912  	// All interleaved filters are executed atomically.
  1913  	Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
  1914  }
  1915  
  1916  func (x *RowFilter_Interleave) Reset() {
  1917  	*x = RowFilter_Interleave{}
  1918  	if protoimpl.UnsafeEnabled {
  1919  		mi := &file_google_bigtable_v2_data_proto_msgTypes[17]
  1920  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1921  		ms.StoreMessageInfo(mi)
  1922  	}
  1923  }
  1924  
  1925  func (x *RowFilter_Interleave) String() string {
  1926  	return protoimpl.X.MessageStringOf(x)
  1927  }
  1928  
  1929  func (*RowFilter_Interleave) ProtoMessage() {}
  1930  
  1931  func (x *RowFilter_Interleave) ProtoReflect() protoreflect.Message {
  1932  	mi := &file_google_bigtable_v2_data_proto_msgTypes[17]
  1933  	if protoimpl.UnsafeEnabled && x != nil {
  1934  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1935  		if ms.LoadMessageInfo() == nil {
  1936  			ms.StoreMessageInfo(mi)
  1937  		}
  1938  		return ms
  1939  	}
  1940  	return mi.MessageOf(x)
  1941  }
  1942  
  1943  // Deprecated: Use RowFilter_Interleave.ProtoReflect.Descriptor instead.
  1944  func (*RowFilter_Interleave) Descriptor() ([]byte, []int) {
  1945  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{10, 1}
  1946  }
  1947  
  1948  func (x *RowFilter_Interleave) GetFilters() []*RowFilter {
  1949  	if x != nil {
  1950  		return x.Filters
  1951  	}
  1952  	return nil
  1953  }
  1954  
  1955  // A RowFilter which evaluates one of two possible RowFilters, depending on
  1956  // whether or not a predicate RowFilter outputs any cells from the input row.
  1957  //
  1958  // IMPORTANT NOTE: The predicate filter does not execute atomically with the
  1959  // true and false filters, which may lead to inconsistent or unexpected
  1960  // results. Additionally, Condition filters have poor performance, especially
  1961  // when filters are set for the false condition.
  1962  type RowFilter_Condition struct {
  1963  	state         protoimpl.MessageState
  1964  	sizeCache     protoimpl.SizeCache
  1965  	unknownFields protoimpl.UnknownFields
  1966  
  1967  	// If `predicate_filter` outputs any cells, then `true_filter` will be
  1968  	// evaluated on the input row. Otherwise, `false_filter` will be evaluated.
  1969  	PredicateFilter *RowFilter `protobuf:"bytes,1,opt,name=predicate_filter,json=predicateFilter,proto3" json:"predicate_filter,omitempty"`
  1970  	// The filter to apply to the input row if `predicate_filter` returns any
  1971  	// results. If not provided, no results will be returned in the true case.
  1972  	TrueFilter *RowFilter `protobuf:"bytes,2,opt,name=true_filter,json=trueFilter,proto3" json:"true_filter,omitempty"`
  1973  	// The filter to apply to the input row if `predicate_filter` does not
  1974  	// return any results. If not provided, no results will be returned in the
  1975  	// false case.
  1976  	FalseFilter *RowFilter `protobuf:"bytes,3,opt,name=false_filter,json=falseFilter,proto3" json:"false_filter,omitempty"`
  1977  }
  1978  
  1979  func (x *RowFilter_Condition) Reset() {
  1980  	*x = RowFilter_Condition{}
  1981  	if protoimpl.UnsafeEnabled {
  1982  		mi := &file_google_bigtable_v2_data_proto_msgTypes[18]
  1983  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1984  		ms.StoreMessageInfo(mi)
  1985  	}
  1986  }
  1987  
  1988  func (x *RowFilter_Condition) String() string {
  1989  	return protoimpl.X.MessageStringOf(x)
  1990  }
  1991  
  1992  func (*RowFilter_Condition) ProtoMessage() {}
  1993  
  1994  func (x *RowFilter_Condition) ProtoReflect() protoreflect.Message {
  1995  	mi := &file_google_bigtable_v2_data_proto_msgTypes[18]
  1996  	if protoimpl.UnsafeEnabled && x != nil {
  1997  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1998  		if ms.LoadMessageInfo() == nil {
  1999  			ms.StoreMessageInfo(mi)
  2000  		}
  2001  		return ms
  2002  	}
  2003  	return mi.MessageOf(x)
  2004  }
  2005  
  2006  // Deprecated: Use RowFilter_Condition.ProtoReflect.Descriptor instead.
  2007  func (*RowFilter_Condition) Descriptor() ([]byte, []int) {
  2008  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{10, 2}
  2009  }
  2010  
  2011  func (x *RowFilter_Condition) GetPredicateFilter() *RowFilter {
  2012  	if x != nil {
  2013  		return x.PredicateFilter
  2014  	}
  2015  	return nil
  2016  }
  2017  
  2018  func (x *RowFilter_Condition) GetTrueFilter() *RowFilter {
  2019  	if x != nil {
  2020  		return x.TrueFilter
  2021  	}
  2022  	return nil
  2023  }
  2024  
  2025  func (x *RowFilter_Condition) GetFalseFilter() *RowFilter {
  2026  	if x != nil {
  2027  		return x.FalseFilter
  2028  	}
  2029  	return nil
  2030  }
  2031  
  2032  // A Mutation which sets the value of the specified cell.
  2033  type Mutation_SetCell struct {
  2034  	state         protoimpl.MessageState
  2035  	sizeCache     protoimpl.SizeCache
  2036  	unknownFields protoimpl.UnknownFields
  2037  
  2038  	// The name of the family into which new data should be written.
  2039  	// Must match `[-_.a-zA-Z0-9]+`
  2040  	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
  2041  	// The qualifier of the column into which new data should be written.
  2042  	// Can be any byte string, including the empty string.
  2043  	ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
  2044  	// The timestamp of the cell into which new data should be written.
  2045  	// Use -1 for current Bigtable server time.
  2046  	// Otherwise, the client should set this value itself, noting that the
  2047  	// default value is a timestamp of zero if the field is left unspecified.
  2048  	// Values must match the granularity of the table (e.g. micros, millis).
  2049  	TimestampMicros int64 `protobuf:"varint,3,opt,name=timestamp_micros,json=timestampMicros,proto3" json:"timestamp_micros,omitempty"`
  2050  	// The value to be written into the specified cell.
  2051  	Value []byte `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
  2052  }
  2053  
  2054  func (x *Mutation_SetCell) Reset() {
  2055  	*x = Mutation_SetCell{}
  2056  	if protoimpl.UnsafeEnabled {
  2057  		mi := &file_google_bigtable_v2_data_proto_msgTypes[19]
  2058  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  2059  		ms.StoreMessageInfo(mi)
  2060  	}
  2061  }
  2062  
  2063  func (x *Mutation_SetCell) String() string {
  2064  	return protoimpl.X.MessageStringOf(x)
  2065  }
  2066  
  2067  func (*Mutation_SetCell) ProtoMessage() {}
  2068  
  2069  func (x *Mutation_SetCell) ProtoReflect() protoreflect.Message {
  2070  	mi := &file_google_bigtable_v2_data_proto_msgTypes[19]
  2071  	if protoimpl.UnsafeEnabled && x != nil {
  2072  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  2073  		if ms.LoadMessageInfo() == nil {
  2074  			ms.StoreMessageInfo(mi)
  2075  		}
  2076  		return ms
  2077  	}
  2078  	return mi.MessageOf(x)
  2079  }
  2080  
  2081  // Deprecated: Use Mutation_SetCell.ProtoReflect.Descriptor instead.
  2082  func (*Mutation_SetCell) Descriptor() ([]byte, []int) {
  2083  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{11, 0}
  2084  }
  2085  
  2086  func (x *Mutation_SetCell) GetFamilyName() string {
  2087  	if x != nil {
  2088  		return x.FamilyName
  2089  	}
  2090  	return ""
  2091  }
  2092  
  2093  func (x *Mutation_SetCell) GetColumnQualifier() []byte {
  2094  	if x != nil {
  2095  		return x.ColumnQualifier
  2096  	}
  2097  	return nil
  2098  }
  2099  
  2100  func (x *Mutation_SetCell) GetTimestampMicros() int64 {
  2101  	if x != nil {
  2102  		return x.TimestampMicros
  2103  	}
  2104  	return 0
  2105  }
  2106  
  2107  func (x *Mutation_SetCell) GetValue() []byte {
  2108  	if x != nil {
  2109  		return x.Value
  2110  	}
  2111  	return nil
  2112  }
  2113  
  2114  // A Mutation which incrementally updates a cell in an `Aggregate` family.
  2115  type Mutation_AddToCell struct {
  2116  	state         protoimpl.MessageState
  2117  	sizeCache     protoimpl.SizeCache
  2118  	unknownFields protoimpl.UnknownFields
  2119  
  2120  	// The name of the `Aggregate` family into which new data should be added.
  2121  	// This must be a family with a `value_type` of `Aggregate`.
  2122  	// Format: `[-_.a-zA-Z0-9]+`
  2123  	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
  2124  	// The qualifier of the column into which new data should be added. This
  2125  	// must be a `raw_value`.
  2126  	ColumnQualifier *Value `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
  2127  	// The timestamp of the cell to which new data should be added. This must
  2128  	// be a `raw_timestamp_micros` that matches the table's `granularity`.
  2129  	Timestamp *Value `protobuf:"bytes,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
  2130  	// The input value to be accumulated into the specified cell. This must be
  2131  	// compatible with the family's `value_type.input_type`.
  2132  	Input *Value `protobuf:"bytes,4,opt,name=input,proto3" json:"input,omitempty"`
  2133  }
  2134  
  2135  func (x *Mutation_AddToCell) Reset() {
  2136  	*x = Mutation_AddToCell{}
  2137  	if protoimpl.UnsafeEnabled {
  2138  		mi := &file_google_bigtable_v2_data_proto_msgTypes[20]
  2139  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  2140  		ms.StoreMessageInfo(mi)
  2141  	}
  2142  }
  2143  
  2144  func (x *Mutation_AddToCell) String() string {
  2145  	return protoimpl.X.MessageStringOf(x)
  2146  }
  2147  
  2148  func (*Mutation_AddToCell) ProtoMessage() {}
  2149  
  2150  func (x *Mutation_AddToCell) ProtoReflect() protoreflect.Message {
  2151  	mi := &file_google_bigtable_v2_data_proto_msgTypes[20]
  2152  	if protoimpl.UnsafeEnabled && x != nil {
  2153  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  2154  		if ms.LoadMessageInfo() == nil {
  2155  			ms.StoreMessageInfo(mi)
  2156  		}
  2157  		return ms
  2158  	}
  2159  	return mi.MessageOf(x)
  2160  }
  2161  
  2162  // Deprecated: Use Mutation_AddToCell.ProtoReflect.Descriptor instead.
  2163  func (*Mutation_AddToCell) Descriptor() ([]byte, []int) {
  2164  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{11, 1}
  2165  }
  2166  
  2167  func (x *Mutation_AddToCell) GetFamilyName() string {
  2168  	if x != nil {
  2169  		return x.FamilyName
  2170  	}
  2171  	return ""
  2172  }
  2173  
  2174  func (x *Mutation_AddToCell) GetColumnQualifier() *Value {
  2175  	if x != nil {
  2176  		return x.ColumnQualifier
  2177  	}
  2178  	return nil
  2179  }
  2180  
  2181  func (x *Mutation_AddToCell) GetTimestamp() *Value {
  2182  	if x != nil {
  2183  		return x.Timestamp
  2184  	}
  2185  	return nil
  2186  }
  2187  
  2188  func (x *Mutation_AddToCell) GetInput() *Value {
  2189  	if x != nil {
  2190  		return x.Input
  2191  	}
  2192  	return nil
  2193  }
  2194  
  2195  // A Mutation which deletes cells from the specified column, optionally
  2196  // restricting the deletions to a given timestamp range.
  2197  type Mutation_DeleteFromColumn struct {
  2198  	state         protoimpl.MessageState
  2199  	sizeCache     protoimpl.SizeCache
  2200  	unknownFields protoimpl.UnknownFields
  2201  
  2202  	// The name of the family from which cells should be deleted.
  2203  	// Must match `[-_.a-zA-Z0-9]+`
  2204  	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
  2205  	// The qualifier of the column from which cells should be deleted.
  2206  	// Can be any byte string, including the empty string.
  2207  	ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
  2208  	// The range of timestamps within which cells should be deleted.
  2209  	TimeRange *TimestampRange `protobuf:"bytes,3,opt,name=time_range,json=timeRange,proto3" json:"time_range,omitempty"`
  2210  }
  2211  
  2212  func (x *Mutation_DeleteFromColumn) Reset() {
  2213  	*x = Mutation_DeleteFromColumn{}
  2214  	if protoimpl.UnsafeEnabled {
  2215  		mi := &file_google_bigtable_v2_data_proto_msgTypes[21]
  2216  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  2217  		ms.StoreMessageInfo(mi)
  2218  	}
  2219  }
  2220  
  2221  func (x *Mutation_DeleteFromColumn) String() string {
  2222  	return protoimpl.X.MessageStringOf(x)
  2223  }
  2224  
  2225  func (*Mutation_DeleteFromColumn) ProtoMessage() {}
  2226  
  2227  func (x *Mutation_DeleteFromColumn) ProtoReflect() protoreflect.Message {
  2228  	mi := &file_google_bigtable_v2_data_proto_msgTypes[21]
  2229  	if protoimpl.UnsafeEnabled && x != nil {
  2230  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  2231  		if ms.LoadMessageInfo() == nil {
  2232  			ms.StoreMessageInfo(mi)
  2233  		}
  2234  		return ms
  2235  	}
  2236  	return mi.MessageOf(x)
  2237  }
  2238  
  2239  // Deprecated: Use Mutation_DeleteFromColumn.ProtoReflect.Descriptor instead.
  2240  func (*Mutation_DeleteFromColumn) Descriptor() ([]byte, []int) {
  2241  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{11, 2}
  2242  }
  2243  
  2244  func (x *Mutation_DeleteFromColumn) GetFamilyName() string {
  2245  	if x != nil {
  2246  		return x.FamilyName
  2247  	}
  2248  	return ""
  2249  }
  2250  
  2251  func (x *Mutation_DeleteFromColumn) GetColumnQualifier() []byte {
  2252  	if x != nil {
  2253  		return x.ColumnQualifier
  2254  	}
  2255  	return nil
  2256  }
  2257  
  2258  func (x *Mutation_DeleteFromColumn) GetTimeRange() *TimestampRange {
  2259  	if x != nil {
  2260  		return x.TimeRange
  2261  	}
  2262  	return nil
  2263  }
  2264  
  2265  // A Mutation which deletes all cells from the specified column family.
  2266  type Mutation_DeleteFromFamily struct {
  2267  	state         protoimpl.MessageState
  2268  	sizeCache     protoimpl.SizeCache
  2269  	unknownFields protoimpl.UnknownFields
  2270  
  2271  	// The name of the family from which cells should be deleted.
  2272  	// Must match `[-_.a-zA-Z0-9]+`
  2273  	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
  2274  }
  2275  
  2276  func (x *Mutation_DeleteFromFamily) Reset() {
  2277  	*x = Mutation_DeleteFromFamily{}
  2278  	if protoimpl.UnsafeEnabled {
  2279  		mi := &file_google_bigtable_v2_data_proto_msgTypes[22]
  2280  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  2281  		ms.StoreMessageInfo(mi)
  2282  	}
  2283  }
  2284  
  2285  func (x *Mutation_DeleteFromFamily) String() string {
  2286  	return protoimpl.X.MessageStringOf(x)
  2287  }
  2288  
  2289  func (*Mutation_DeleteFromFamily) ProtoMessage() {}
  2290  
  2291  func (x *Mutation_DeleteFromFamily) ProtoReflect() protoreflect.Message {
  2292  	mi := &file_google_bigtable_v2_data_proto_msgTypes[22]
  2293  	if protoimpl.UnsafeEnabled && x != nil {
  2294  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  2295  		if ms.LoadMessageInfo() == nil {
  2296  			ms.StoreMessageInfo(mi)
  2297  		}
  2298  		return ms
  2299  	}
  2300  	return mi.MessageOf(x)
  2301  }
  2302  
  2303  // Deprecated: Use Mutation_DeleteFromFamily.ProtoReflect.Descriptor instead.
  2304  func (*Mutation_DeleteFromFamily) Descriptor() ([]byte, []int) {
  2305  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{11, 3}
  2306  }
  2307  
  2308  func (x *Mutation_DeleteFromFamily) GetFamilyName() string {
  2309  	if x != nil {
  2310  		return x.FamilyName
  2311  	}
  2312  	return ""
  2313  }
  2314  
  2315  // A Mutation which deletes all cells from the containing row.
  2316  type Mutation_DeleteFromRow struct {
  2317  	state         protoimpl.MessageState
  2318  	sizeCache     protoimpl.SizeCache
  2319  	unknownFields protoimpl.UnknownFields
  2320  }
  2321  
  2322  func (x *Mutation_DeleteFromRow) Reset() {
  2323  	*x = Mutation_DeleteFromRow{}
  2324  	if protoimpl.UnsafeEnabled {
  2325  		mi := &file_google_bigtable_v2_data_proto_msgTypes[23]
  2326  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  2327  		ms.StoreMessageInfo(mi)
  2328  	}
  2329  }
  2330  
  2331  func (x *Mutation_DeleteFromRow) String() string {
  2332  	return protoimpl.X.MessageStringOf(x)
  2333  }
  2334  
  2335  func (*Mutation_DeleteFromRow) ProtoMessage() {}
  2336  
  2337  func (x *Mutation_DeleteFromRow) ProtoReflect() protoreflect.Message {
  2338  	mi := &file_google_bigtable_v2_data_proto_msgTypes[23]
  2339  	if protoimpl.UnsafeEnabled && x != nil {
  2340  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  2341  		if ms.LoadMessageInfo() == nil {
  2342  			ms.StoreMessageInfo(mi)
  2343  		}
  2344  		return ms
  2345  	}
  2346  	return mi.MessageOf(x)
  2347  }
  2348  
  2349  // Deprecated: Use Mutation_DeleteFromRow.ProtoReflect.Descriptor instead.
  2350  func (*Mutation_DeleteFromRow) Descriptor() ([]byte, []int) {
  2351  	return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{11, 4}
  2352  }
  2353  
  2354  var File_google_bigtable_v2_data_proto protoreflect.FileDescriptor
  2355  
  2356  var file_google_bigtable_v2_data_proto_rawDesc = []byte{
  2357  	0x0a, 0x1d, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c,
  2358  	0x65, 0x2f, 0x76, 0x32, 0x2f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
  2359  	0x12, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65,
  2360  	0x2e, 0x76, 0x32, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f,
  2361  	0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x2e, 0x70,
  2362  	0x72, 0x6f, 0x74, 0x6f, 0x22, 0x4f, 0x0a, 0x03, 0x52, 0x6f, 0x77, 0x12, 0x10, 0x0a, 0x03, 0x6b,
  2363  	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x36, 0x0a,
  2364  	0x08, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x69, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32,
  2365  	0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c,
  2366  	0x65, 0x2e, 0x76, 0x32, 0x2e, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x52, 0x08, 0x66, 0x61, 0x6d,
  2367  	0x69, 0x6c, 0x69, 0x65, 0x73, 0x22, 0x52, 0x0a, 0x06, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12,
  2368  	0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e,
  2369  	0x61, 0x6d, 0x65, 0x12, 0x34, 0x0a, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x02,
  2370  	0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69,
  2371  	0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e,
  2372  	0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x22, 0x56, 0x0a, 0x06, 0x43, 0x6f, 0x6c,
  2373  	0x75, 0x6d, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72,
  2374  	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65,
  2375  	0x72, 0x12, 0x2e, 0x0a, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
  2376  	0x32, 0x18, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62,
  2377  	0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c,
  2378  	0x73, 0x22, 0x5f, 0x0a, 0x04, 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x29, 0x0a, 0x10, 0x74, 0x69, 0x6d,
  2379  	0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x18, 0x01, 0x20,
  2380  	0x01, 0x28, 0x03, 0x52, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4d, 0x69,
  2381  	0x63, 0x72, 0x6f, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
  2382  	0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x61,
  2383  	0x62, 0x65, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65,
  2384  	0x6c, 0x73, 0x22, 0x81, 0x01, 0x0a, 0x05, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1d, 0x0a, 0x09,
  2385  	0x72, 0x61, 0x77, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x48,
  2386  	0x00, 0x52, 0x08, 0x72, 0x61, 0x77, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x32, 0x0a, 0x14, 0x72,
  2387  	0x61, 0x77, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6d, 0x69, 0x63,
  2388  	0x72, 0x6f, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x12, 0x72, 0x61, 0x77,
  2389  	0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x12,
  2390  	0x1d, 0x0a, 0x09, 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01,
  2391  	0x28, 0x03, 0x48, 0x00, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x06,
  2392  	0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x22, 0xc2, 0x01, 0x0a, 0x08, 0x52, 0x6f, 0x77, 0x52, 0x61,
  2393  	0x6e, 0x67, 0x65, 0x12, 0x2a, 0x0a, 0x10, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x6b, 0x65, 0x79,
  2394  	0x5f, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52,
  2395  	0x0e, 0x73, 0x74, 0x61, 0x72, 0x74, 0x4b, 0x65, 0x79, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x12,
  2396  	0x26, 0x0a, 0x0e, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x6f, 0x70, 0x65,
  2397  	0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0c, 0x73, 0x74, 0x61, 0x72, 0x74,
  2398  	0x4b, 0x65, 0x79, 0x4f, 0x70, 0x65, 0x6e, 0x12, 0x22, 0x0a, 0x0c, 0x65, 0x6e, 0x64, 0x5f, 0x6b,
  2399  	0x65, 0x79, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52,
  2400  	0x0a, 0x65, 0x6e, 0x64, 0x4b, 0x65, 0x79, 0x4f, 0x70, 0x65, 0x6e, 0x12, 0x26, 0x0a, 0x0e, 0x65,
  2401  	0x6e, 0x64, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x18, 0x04, 0x20,
  2402  	0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x0c, 0x65, 0x6e, 0x64, 0x4b, 0x65, 0x79, 0x43, 0x6c, 0x6f,
  2403  	0x73, 0x65, 0x64, 0x42, 0x0b, 0x0a, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x6b, 0x65, 0x79,
  2404  	0x42, 0x09, 0x0a, 0x07, 0x65, 0x6e, 0x64, 0x5f, 0x6b, 0x65, 0x79, 0x22, 0x60, 0x0a, 0x06, 0x52,
  2405  	0x6f, 0x77, 0x53, 0x65, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f, 0x77, 0x5f, 0x6b, 0x65, 0x79,
  2406  	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x07, 0x72, 0x6f, 0x77, 0x4b, 0x65, 0x79, 0x73,
  2407  	0x12, 0x3b, 0x0a, 0x0a, 0x72, 0x6f, 0x77, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x18, 0x02,
  2408  	0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69,
  2409  	0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x52, 0x61, 0x6e,
  2410  	0x67, 0x65, 0x52, 0x09, 0x72, 0x6f, 0x77, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x22, 0xa2, 0x02,
  2411  	0x0a, 0x0b, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1f, 0x0a,
  2412  	0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
  2413  	0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x36,
  2414  	0x0a, 0x16, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65,
  2415  	0x72, 0x5f, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00,
  2416  	0x52, 0x14, 0x73, 0x74, 0x61, 0x72, 0x74, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72,
  2417  	0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x12, 0x32, 0x0a, 0x14, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f,
  2418  	0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x18, 0x03,
  2419  	0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x12, 0x73, 0x74, 0x61, 0x72, 0x74, 0x51, 0x75, 0x61,
  2420  	0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x4f, 0x70, 0x65, 0x6e, 0x12, 0x32, 0x0a, 0x14, 0x65, 0x6e,
  2421  	0x64, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x6f, 0x73,
  2422  	0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x12, 0x65, 0x6e, 0x64, 0x51,
  2423  	0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x12, 0x2e,
  2424  	0x0a, 0x12, 0x65, 0x6e, 0x64, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x5f,
  2425  	0x6f, 0x70, 0x65, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x10, 0x65, 0x6e,
  2426  	0x64, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x4f, 0x70, 0x65, 0x6e, 0x42, 0x11,
  2427  	0x0a, 0x0f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65,
  2428  	0x72, 0x42, 0x0f, 0x0a, 0x0d, 0x65, 0x6e, 0x64, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69,
  2429  	0x65, 0x72, 0x22, 0x78, 0x0a, 0x0e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52,
  2430  	0x61, 0x6e, 0x67, 0x65, 0x12, 0x34, 0x0a, 0x16, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69,
  2431  	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x18, 0x01,
  2432  	0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x73,
  2433  	0x74, 0x61, 0x6d, 0x70, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x65, 0x6e,
  2434  	0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6d, 0x69, 0x63, 0x72,
  2435  	0x6f, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d,
  2436  	0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x22, 0xd8, 0x01, 0x0a,
  2437  	0x0a, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x2e, 0x0a, 0x12, 0x73,
  2438  	0x74, 0x61, 0x72, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x63, 0x6c, 0x6f, 0x73, 0x65,
  2439  	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x10, 0x73, 0x74, 0x61, 0x72, 0x74,
  2440  	0x56, 0x61, 0x6c, 0x75, 0x65, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x12, 0x2a, 0x0a, 0x10, 0x73,
  2441  	0x74, 0x61, 0x72, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x18,
  2442  	0x02, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0e, 0x73, 0x74, 0x61, 0x72, 0x74, 0x56, 0x61,
  2443  	0x6c, 0x75, 0x65, 0x4f, 0x70, 0x65, 0x6e, 0x12, 0x2a, 0x0a, 0x10, 0x65, 0x6e, 0x64, 0x5f, 0x76,
  2444  	0x61, 0x6c, 0x75, 0x65, 0x5f, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28,
  2445  	0x0c, 0x48, 0x01, 0x52, 0x0e, 0x65, 0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x43, 0x6c, 0x6f,
  2446  	0x73, 0x65, 0x64, 0x12, 0x26, 0x0a, 0x0e, 0x65, 0x6e, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65,
  2447  	0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x0c, 0x65,
  2448  	0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x65, 0x6e, 0x42, 0x0d, 0x0a, 0x0b, 0x73,
  2449  	0x74, 0x61, 0x72, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x65, 0x6e,
  2450  	0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xfc, 0x0b, 0x0a, 0x09, 0x52, 0x6f, 0x77, 0x46,
  2451  	0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x3b, 0x0a, 0x05, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x01,
  2452  	0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69,
  2453  	0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c,
  2454  	0x74, 0x65, 0x72, 0x2e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x48, 0x00, 0x52, 0x05, 0x63, 0x68, 0x61,
  2455  	0x69, 0x6e, 0x12, 0x4a, 0x0a, 0x0a, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6c, 0x65, 0x61, 0x76, 0x65,
  2456  	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
  2457  	0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x46,
  2458  	0x69, 0x6c, 0x74, 0x65, 0x72, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6c, 0x65, 0x61, 0x76, 0x65,
  2459  	0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x12, 0x47,
  2460  	0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28,
  2461  	0x0b, 0x32, 0x27, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61,
  2462  	0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72,
  2463  	0x2e, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x09, 0x63, 0x6f,
  2464  	0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x04, 0x73, 0x69, 0x6e, 0x6b, 0x18,
  2465  	0x10, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x04, 0x73, 0x69, 0x6e, 0x6b, 0x12, 0x28, 0x0a,
  2466  	0x0f, 0x70, 0x61, 0x73, 0x73, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72,
  2467  	0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0d, 0x70, 0x61, 0x73, 0x73, 0x41, 0x6c,
  2468  	0x6c, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x10, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
  2469  	0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x12, 0x20, 0x01, 0x28,
  2470  	0x08, 0x48, 0x00, 0x52, 0x0e, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x41, 0x6c, 0x6c, 0x46, 0x69, 0x6c,
  2471  	0x74, 0x65, 0x72, 0x12, 0x31, 0x0a, 0x14, 0x72, 0x6f, 0x77, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x72,
  2472  	0x65, 0x67, 0x65, 0x78, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28,
  2473  	0x0c, 0x48, 0x00, 0x52, 0x11, 0x72, 0x6f, 0x77, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x67, 0x65, 0x78,
  2474  	0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x2c, 0x0a, 0x11, 0x72, 0x6f, 0x77, 0x5f, 0x73, 0x61,
  2475  	0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x0e, 0x20, 0x01, 0x28,
  2476  	0x01, 0x48, 0x00, 0x52, 0x0f, 0x72, 0x6f, 0x77, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x46, 0x69,
  2477  	0x6c, 0x74, 0x65, 0x72, 0x12, 0x39, 0x0a, 0x18, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e,
  2478  	0x61, 0x6d, 0x65, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72,
  2479  	0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x15, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79,
  2480  	0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x67, 0x65, 0x78, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12,
  2481  	0x43, 0x0a, 0x1d, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66,
  2482  	0x69, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72,
  2483  	0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x1a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e,
  2484  	0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x65, 0x67, 0x65, 0x78, 0x46, 0x69,
  2485  	0x6c, 0x74, 0x65, 0x72, 0x12, 0x51, 0x0a, 0x13, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x72,
  2486  	0x61, 0x6e, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x07, 0x20, 0x01, 0x28,
  2487  	0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61,
  2488  	0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x61, 0x6e,
  2489  	0x67, 0x65, 0x48, 0x00, 0x52, 0x11, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x61, 0x6e, 0x67,
  2490  	0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x5a, 0x0a, 0x16, 0x74, 0x69, 0x6d, 0x65, 0x73,
  2491  	0x74, 0x61, 0x6d, 0x70, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65,
  2492  	0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
  2493  	0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x54, 0x69, 0x6d,
  2494  	0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48, 0x00, 0x52, 0x14, 0x74,
  2495  	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x46, 0x69, 0x6c,
  2496  	0x74, 0x65, 0x72, 0x12, 0x2e, 0x0a, 0x12, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x72, 0x65, 0x67,
  2497  	0x65, 0x78, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c, 0x48,
  2498  	0x00, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x67, 0x65, 0x78, 0x46, 0x69, 0x6c,
  2499  	0x74, 0x65, 0x72, 0x12, 0x4e, 0x0a, 0x12, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x72, 0x61, 0x6e,
  2500  	0x67, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32,
  2501  	0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c,
  2502  	0x65, 0x2e, 0x76, 0x32, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48,
  2503  	0x00, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x46, 0x69, 0x6c,
  2504  	0x74, 0x65, 0x72, 0x12, 0x3e, 0x0a, 0x1b, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x5f, 0x70, 0x65, 0x72,
  2505  	0x5f, 0x72, 0x6f, 0x77, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x74,
  2506  	0x65, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x17, 0x63, 0x65, 0x6c, 0x6c,
  2507  	0x73, 0x50, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x46, 0x69, 0x6c,
  2508  	0x74, 0x65, 0x72, 0x12, 0x3c, 0x0a, 0x1a, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x5f, 0x70, 0x65, 0x72,
  2509  	0x5f, 0x72, 0x6f, 0x77, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65,
  2510  	0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x16, 0x63, 0x65, 0x6c, 0x6c, 0x73,
  2511  	0x50, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x46, 0x69, 0x6c, 0x74, 0x65,
  2512  	0x72, 0x12, 0x42, 0x0a, 0x1d, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x63,
  2513  	0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x74,
  2514  	0x65, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x19, 0x63, 0x65, 0x6c, 0x6c,
  2515  	0x73, 0x50, 0x65, 0x72, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x46,
  2516  	0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x38, 0x0a, 0x17, 0x73, 0x74, 0x72, 0x69, 0x70, 0x5f, 0x76,
  2517  	0x61, 0x6c, 0x75, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x72,
  2518  	0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x15, 0x73, 0x74, 0x72, 0x69, 0x70, 0x56,
  2519  	0x61, 0x6c, 0x75, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x72, 0x12,
  2520  	0x38, 0x0a, 0x17, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x5f, 0x74,
  2521  	0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x72, 0x18, 0x13, 0x20, 0x01, 0x28, 0x09,
  2522  	0x48, 0x00, 0x52, 0x15, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x54, 0x72,
  2523  	0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x72, 0x1a, 0x40, 0x0a, 0x05, 0x43, 0x68, 0x61,
  2524  	0x69, 0x6e, 0x12, 0x37, 0x0a, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20,
  2525  	0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67,
  2526  	0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74,
  2527  	0x65, 0x72, 0x52, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x1a, 0x45, 0x0a, 0x0a, 0x49,
  2528  	0x6e, 0x74, 0x65, 0x72, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x66, 0x69, 0x6c,
  2529  	0x74, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f,
  2530  	0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e,
  2531  	0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65,
  2532  	0x72, 0x73, 0x1a, 0xd7, 0x01, 0x0a, 0x09, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e,
  2533  	0x12, 0x48, 0x0a, 0x10, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x5f, 0x66, 0x69,
  2534  	0x6c, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f,
  2535  	0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e,
  2536  	0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x0f, 0x70, 0x72, 0x65, 0x64, 0x69,
  2537  	0x63, 0x61, 0x74, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x3e, 0x0a, 0x0b, 0x74, 0x72,
  2538  	0x75, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
  2539  	0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c,
  2540  	0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x0a,
  2541  	0x74, 0x72, 0x75, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x40, 0x0a, 0x0c, 0x66, 0x61,
  2542  	0x6c, 0x73, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b,
  2543  	0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62,
  2544  	0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52,
  2545  	0x0b, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x42, 0x08, 0x0a, 0x06,
  2546  	0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0x99, 0x08, 0x0a, 0x08, 0x4d, 0x75, 0x74, 0x61, 0x74,
  2547  	0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x08, 0x73, 0x65, 0x74, 0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x18,
  2548  	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62,
  2549  	0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x4d, 0x75, 0x74, 0x61, 0x74,
  2550  	0x69, 0x6f, 0x6e, 0x2e, 0x53, 0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x48, 0x00, 0x52, 0x07, 0x73,
  2551  	0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x48, 0x0a, 0x0b, 0x61, 0x64, 0x64, 0x5f, 0x74, 0x6f,
  2552  	0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, 0x6f,
  2553  	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32,
  2554  	0x2e, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x41, 0x64, 0x64, 0x54, 0x6f, 0x43,
  2555  	0x65, 0x6c, 0x6c, 0x48, 0x00, 0x52, 0x09, 0x61, 0x64, 0x64, 0x54, 0x6f, 0x43, 0x65, 0x6c, 0x6c,
  2556  	0x12, 0x5d, 0x0a, 0x12, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f,
  2557  	0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x67,
  2558  	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76,
  2559  	0x32, 0x2e, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74,
  2560  	0x65, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x48, 0x00, 0x52, 0x10, 0x64,
  2561  	0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12,
  2562  	0x5d, 0x0a, 0x12, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x66,
  2563  	0x61, 0x6d, 0x69, 0x6c, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x67, 0x6f,
  2564  	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32,
  2565  	0x2e, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65,
  2566  	0x46, 0x72, 0x6f, 0x6d, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x48, 0x00, 0x52, 0x10, 0x64, 0x65,
  2567  	0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x54,
  2568  	0x0a, 0x0f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x72, 0x6f,
  2569  	0x77, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
  2570  	0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x4d, 0x75, 0x74,
  2571  	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d,
  2572  	0x52, 0x6f, 0x77, 0x48, 0x00, 0x52, 0x0d, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f,
  2573  	0x6d, 0x52, 0x6f, 0x77, 0x1a, 0x96, 0x01, 0x0a, 0x07, 0x53, 0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c,
  2574  	0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18,
  2575  	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d,
  2576  	0x65, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x71, 0x75, 0x61, 0x6c,
  2577  	0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x63, 0x6f, 0x6c,
  2578  	0x75, 0x6d, 0x6e, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x29, 0x0a, 0x10,
  2579  	0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73,
  2580  	0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d,
  2581  	0x70, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
  2582  	0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x1a, 0xdc, 0x01,
  2583  	0x0a, 0x09, 0x41, 0x64, 0x64, 0x54, 0x6f, 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x66,
  2584  	0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
  2585  	0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x44, 0x0a, 0x10,
  2586  	0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72,
  2587  	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
  2588  	0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x56, 0x61, 0x6c, 0x75,
  2589  	0x65, 0x52, 0x0f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69,
  2590  	0x65, 0x72, 0x12, 0x37, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18,
  2591  	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62,
  2592  	0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65,
  2593  	0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2f, 0x0a, 0x05, 0x69,
  2594  	0x6e, 0x70, 0x75, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f,
  2595  	0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e,
  2596  	0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x1a, 0xa1, 0x01, 0x0a,
  2597  	0x10, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x6f, 0x6c, 0x75, 0x6d,
  2598  	0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
  2599  	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61,
  2600  	0x6d, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x71, 0x75, 0x61,
  2601  	0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x63, 0x6f,
  2602  	0x6c, 0x75, 0x6d, 0x6e, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x41, 0x0a,
  2603  	0x0a, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28,
  2604  	0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61,
  2605  	0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
  2606  	0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65,
  2607  	0x1a, 0x33, 0x0a, 0x10, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x46, 0x61,
  2608  	0x6d, 0x69, 0x6c, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e,
  2609  	0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c,
  2610  	0x79, 0x4e, 0x61, 0x6d, 0x65, 0x1a, 0x0f, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46,
  2611  	0x72, 0x6f, 0x6d, 0x52, 0x6f, 0x77, 0x42, 0x0a, 0x0a, 0x08, 0x6d, 0x75, 0x74, 0x61, 0x74, 0x69,
  2612  	0x6f, 0x6e, 0x22, 0xbb, 0x01, 0x0a, 0x13, 0x52, 0x65, 0x61, 0x64, 0x4d, 0x6f, 0x64, 0x69, 0x66,
  2613  	0x79, 0x57, 0x72, 0x69, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61,
  2614  	0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
  2615  	0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x63,
  2616  	0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18,
  2617  	0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x51, 0x75, 0x61,
  2618  	0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x23, 0x0a, 0x0c, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64,
  2619  	0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0b,
  2620  	0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2b, 0x0a, 0x10, 0x69,
  2621  	0x6e, 0x63, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18,
  2622  	0x04, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0f, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x6d, 0x65,
  2623  	0x6e, 0x74, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x06, 0x0a, 0x04, 0x72, 0x75, 0x6c, 0x65,
  2624  	0x22, 0x4c, 0x0a, 0x0f, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74,
  2625  	0x69, 0x6f, 0x6e, 0x12, 0x39, 0x0a, 0x09, 0x72, 0x6f, 0x77, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65,
  2626  	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
  2627  	0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x52,
  2628  	0x61, 0x6e, 0x67, 0x65, 0x52, 0x08, 0x72, 0x6f, 0x77, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x22, 0x5f,
  2629  	0x0a, 0x18, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x43, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x61,
  2630  	0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x43, 0x0a, 0x06, 0x74, 0x6f,
  2631  	0x6b, 0x65, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x6f,
  2632  	0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e,
  2633  	0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x43, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x61, 0x74, 0x69,
  2634  	0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x06, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x22,
  2635  	0x72, 0x0a, 0x17, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x43, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75,
  2636  	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x41, 0x0a, 0x09, 0x70, 0x61,
  2637  	0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e,
  2638  	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e,
  2639  	0x76, 0x32, 0x2e, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69,
  2640  	0x6f, 0x6e, 0x52, 0x09, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a,
  2641  	0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f,
  2642  	0x6b, 0x65, 0x6e, 0x42, 0xb5, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
  2643  	0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x42, 0x09,
  2644  	0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x6f, 0x6f,
  2645  	0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x67,
  2646  	0x65, 0x6e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x61, 0x70,
  2647  	0x69, 0x73, 0x2f, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2f, 0x76, 0x32, 0x3b, 0x62,
  2648  	0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0xaa, 0x02, 0x18, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
  2649  	0x2e, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x2e, 0x42, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e,
  2650  	0x56, 0x32, 0xca, 0x02, 0x18, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x5c, 0x43, 0x6c, 0x6f, 0x75,
  2651  	0x64, 0x5c, 0x42, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5c, 0x56, 0x32, 0xea, 0x02, 0x1b,
  2652  	0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x3a, 0x3a, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x3a, 0x3a, 0x42,
  2653  	0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x3a, 0x56, 0x32, 0x62, 0x06, 0x70, 0x72, 0x6f,
  2654  	0x74, 0x6f, 0x33,
  2655  }
  2656  
  2657  var (
  2658  	file_google_bigtable_v2_data_proto_rawDescOnce sync.Once
  2659  	file_google_bigtable_v2_data_proto_rawDescData = file_google_bigtable_v2_data_proto_rawDesc
  2660  )
  2661  
  2662  func file_google_bigtable_v2_data_proto_rawDescGZIP() []byte {
  2663  	file_google_bigtable_v2_data_proto_rawDescOnce.Do(func() {
  2664  		file_google_bigtable_v2_data_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_bigtable_v2_data_proto_rawDescData)
  2665  	})
  2666  	return file_google_bigtable_v2_data_proto_rawDescData
  2667  }
  2668  
  2669  var file_google_bigtable_v2_data_proto_msgTypes = make([]protoimpl.MessageInfo, 24)
  2670  var file_google_bigtable_v2_data_proto_goTypes = []interface{}{
  2671  	(*Row)(nil),                       // 0: google.bigtable.v2.Row
  2672  	(*Family)(nil),                    // 1: google.bigtable.v2.Family
  2673  	(*Column)(nil),                    // 2: google.bigtable.v2.Column
  2674  	(*Cell)(nil),                      // 3: google.bigtable.v2.Cell
  2675  	(*Value)(nil),                     // 4: google.bigtable.v2.Value
  2676  	(*RowRange)(nil),                  // 5: google.bigtable.v2.RowRange
  2677  	(*RowSet)(nil),                    // 6: google.bigtable.v2.RowSet
  2678  	(*ColumnRange)(nil),               // 7: google.bigtable.v2.ColumnRange
  2679  	(*TimestampRange)(nil),            // 8: google.bigtable.v2.TimestampRange
  2680  	(*ValueRange)(nil),                // 9: google.bigtable.v2.ValueRange
  2681  	(*RowFilter)(nil),                 // 10: google.bigtable.v2.RowFilter
  2682  	(*Mutation)(nil),                  // 11: google.bigtable.v2.Mutation
  2683  	(*ReadModifyWriteRule)(nil),       // 12: google.bigtable.v2.ReadModifyWriteRule
  2684  	(*StreamPartition)(nil),           // 13: google.bigtable.v2.StreamPartition
  2685  	(*StreamContinuationTokens)(nil),  // 14: google.bigtable.v2.StreamContinuationTokens
  2686  	(*StreamContinuationToken)(nil),   // 15: google.bigtable.v2.StreamContinuationToken
  2687  	(*RowFilter_Chain)(nil),           // 16: google.bigtable.v2.RowFilter.Chain
  2688  	(*RowFilter_Interleave)(nil),      // 17: google.bigtable.v2.RowFilter.Interleave
  2689  	(*RowFilter_Condition)(nil),       // 18: google.bigtable.v2.RowFilter.Condition
  2690  	(*Mutation_SetCell)(nil),          // 19: google.bigtable.v2.Mutation.SetCell
  2691  	(*Mutation_AddToCell)(nil),        // 20: google.bigtable.v2.Mutation.AddToCell
  2692  	(*Mutation_DeleteFromColumn)(nil), // 21: google.bigtable.v2.Mutation.DeleteFromColumn
  2693  	(*Mutation_DeleteFromFamily)(nil), // 22: google.bigtable.v2.Mutation.DeleteFromFamily
  2694  	(*Mutation_DeleteFromRow)(nil),    // 23: google.bigtable.v2.Mutation.DeleteFromRow
  2695  }
  2696  var file_google_bigtable_v2_data_proto_depIdxs = []int32{
  2697  	1,  // 0: google.bigtable.v2.Row.families:type_name -> google.bigtable.v2.Family
  2698  	2,  // 1: google.bigtable.v2.Family.columns:type_name -> google.bigtable.v2.Column
  2699  	3,  // 2: google.bigtable.v2.Column.cells:type_name -> google.bigtable.v2.Cell
  2700  	5,  // 3: google.bigtable.v2.RowSet.row_ranges:type_name -> google.bigtable.v2.RowRange
  2701  	16, // 4: google.bigtable.v2.RowFilter.chain:type_name -> google.bigtable.v2.RowFilter.Chain
  2702  	17, // 5: google.bigtable.v2.RowFilter.interleave:type_name -> google.bigtable.v2.RowFilter.Interleave
  2703  	18, // 6: google.bigtable.v2.RowFilter.condition:type_name -> google.bigtable.v2.RowFilter.Condition
  2704  	7,  // 7: google.bigtable.v2.RowFilter.column_range_filter:type_name -> google.bigtable.v2.ColumnRange
  2705  	8,  // 8: google.bigtable.v2.RowFilter.timestamp_range_filter:type_name -> google.bigtable.v2.TimestampRange
  2706  	9,  // 9: google.bigtable.v2.RowFilter.value_range_filter:type_name -> google.bigtable.v2.ValueRange
  2707  	19, // 10: google.bigtable.v2.Mutation.set_cell:type_name -> google.bigtable.v2.Mutation.SetCell
  2708  	20, // 11: google.bigtable.v2.Mutation.add_to_cell:type_name -> google.bigtable.v2.Mutation.AddToCell
  2709  	21, // 12: google.bigtable.v2.Mutation.delete_from_column:type_name -> google.bigtable.v2.Mutation.DeleteFromColumn
  2710  	22, // 13: google.bigtable.v2.Mutation.delete_from_family:type_name -> google.bigtable.v2.Mutation.DeleteFromFamily
  2711  	23, // 14: google.bigtable.v2.Mutation.delete_from_row:type_name -> google.bigtable.v2.Mutation.DeleteFromRow
  2712  	5,  // 15: google.bigtable.v2.StreamPartition.row_range:type_name -> google.bigtable.v2.RowRange
  2713  	15, // 16: google.bigtable.v2.StreamContinuationTokens.tokens:type_name -> google.bigtable.v2.StreamContinuationToken
  2714  	13, // 17: google.bigtable.v2.StreamContinuationToken.partition:type_name -> google.bigtable.v2.StreamPartition
  2715  	10, // 18: google.bigtable.v2.RowFilter.Chain.filters:type_name -> google.bigtable.v2.RowFilter
  2716  	10, // 19: google.bigtable.v2.RowFilter.Interleave.filters:type_name -> google.bigtable.v2.RowFilter
  2717  	10, // 20: google.bigtable.v2.RowFilter.Condition.predicate_filter:type_name -> google.bigtable.v2.RowFilter
  2718  	10, // 21: google.bigtable.v2.RowFilter.Condition.true_filter:type_name -> google.bigtable.v2.RowFilter
  2719  	10, // 22: google.bigtable.v2.RowFilter.Condition.false_filter:type_name -> google.bigtable.v2.RowFilter
  2720  	4,  // 23: google.bigtable.v2.Mutation.AddToCell.column_qualifier:type_name -> google.bigtable.v2.Value
  2721  	4,  // 24: google.bigtable.v2.Mutation.AddToCell.timestamp:type_name -> google.bigtable.v2.Value
  2722  	4,  // 25: google.bigtable.v2.Mutation.AddToCell.input:type_name -> google.bigtable.v2.Value
  2723  	8,  // 26: google.bigtable.v2.Mutation.DeleteFromColumn.time_range:type_name -> google.bigtable.v2.TimestampRange
  2724  	27, // [27:27] is the sub-list for method output_type
  2725  	27, // [27:27] is the sub-list for method input_type
  2726  	27, // [27:27] is the sub-list for extension type_name
  2727  	27, // [27:27] is the sub-list for extension extendee
  2728  	0,  // [0:27] is the sub-list for field type_name
  2729  }
  2730  
  2731  func init() { file_google_bigtable_v2_data_proto_init() }
  2732  func file_google_bigtable_v2_data_proto_init() {
  2733  	if File_google_bigtable_v2_data_proto != nil {
  2734  		return
  2735  	}
  2736  	if !protoimpl.UnsafeEnabled {
  2737  		file_google_bigtable_v2_data_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
  2738  			switch v := v.(*Row); i {
  2739  			case 0:
  2740  				return &v.state
  2741  			case 1:
  2742  				return &v.sizeCache
  2743  			case 2:
  2744  				return &v.unknownFields
  2745  			default:
  2746  				return nil
  2747  			}
  2748  		}
  2749  		file_google_bigtable_v2_data_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
  2750  			switch v := v.(*Family); i {
  2751  			case 0:
  2752  				return &v.state
  2753  			case 1:
  2754  				return &v.sizeCache
  2755  			case 2:
  2756  				return &v.unknownFields
  2757  			default:
  2758  				return nil
  2759  			}
  2760  		}
  2761  		file_google_bigtable_v2_data_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
  2762  			switch v := v.(*Column); i {
  2763  			case 0:
  2764  				return &v.state
  2765  			case 1:
  2766  				return &v.sizeCache
  2767  			case 2:
  2768  				return &v.unknownFields
  2769  			default:
  2770  				return nil
  2771  			}
  2772  		}
  2773  		file_google_bigtable_v2_data_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
  2774  			switch v := v.(*Cell); i {
  2775  			case 0:
  2776  				return &v.state
  2777  			case 1:
  2778  				return &v.sizeCache
  2779  			case 2:
  2780  				return &v.unknownFields
  2781  			default:
  2782  				return nil
  2783  			}
  2784  		}
  2785  		file_google_bigtable_v2_data_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
  2786  			switch v := v.(*Value); i {
  2787  			case 0:
  2788  				return &v.state
  2789  			case 1:
  2790  				return &v.sizeCache
  2791  			case 2:
  2792  				return &v.unknownFields
  2793  			default:
  2794  				return nil
  2795  			}
  2796  		}
  2797  		file_google_bigtable_v2_data_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
  2798  			switch v := v.(*RowRange); i {
  2799  			case 0:
  2800  				return &v.state
  2801  			case 1:
  2802  				return &v.sizeCache
  2803  			case 2:
  2804  				return &v.unknownFields
  2805  			default:
  2806  				return nil
  2807  			}
  2808  		}
  2809  		file_google_bigtable_v2_data_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
  2810  			switch v := v.(*RowSet); i {
  2811  			case 0:
  2812  				return &v.state
  2813  			case 1:
  2814  				return &v.sizeCache
  2815  			case 2:
  2816  				return &v.unknownFields
  2817  			default:
  2818  				return nil
  2819  			}
  2820  		}
  2821  		file_google_bigtable_v2_data_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
  2822  			switch v := v.(*ColumnRange); i {
  2823  			case 0:
  2824  				return &v.state
  2825  			case 1:
  2826  				return &v.sizeCache
  2827  			case 2:
  2828  				return &v.unknownFields
  2829  			default:
  2830  				return nil
  2831  			}
  2832  		}
  2833  		file_google_bigtable_v2_data_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
  2834  			switch v := v.(*TimestampRange); i {
  2835  			case 0:
  2836  				return &v.state
  2837  			case 1:
  2838  				return &v.sizeCache
  2839  			case 2:
  2840  				return &v.unknownFields
  2841  			default:
  2842  				return nil
  2843  			}
  2844  		}
  2845  		file_google_bigtable_v2_data_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
  2846  			switch v := v.(*ValueRange); i {
  2847  			case 0:
  2848  				return &v.state
  2849  			case 1:
  2850  				return &v.sizeCache
  2851  			case 2:
  2852  				return &v.unknownFields
  2853  			default:
  2854  				return nil
  2855  			}
  2856  		}
  2857  		file_google_bigtable_v2_data_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
  2858  			switch v := v.(*RowFilter); i {
  2859  			case 0:
  2860  				return &v.state
  2861  			case 1:
  2862  				return &v.sizeCache
  2863  			case 2:
  2864  				return &v.unknownFields
  2865  			default:
  2866  				return nil
  2867  			}
  2868  		}
  2869  		file_google_bigtable_v2_data_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
  2870  			switch v := v.(*Mutation); i {
  2871  			case 0:
  2872  				return &v.state
  2873  			case 1:
  2874  				return &v.sizeCache
  2875  			case 2:
  2876  				return &v.unknownFields
  2877  			default:
  2878  				return nil
  2879  			}
  2880  		}
  2881  		file_google_bigtable_v2_data_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
  2882  			switch v := v.(*ReadModifyWriteRule); i {
  2883  			case 0:
  2884  				return &v.state
  2885  			case 1:
  2886  				return &v.sizeCache
  2887  			case 2:
  2888  				return &v.unknownFields
  2889  			default:
  2890  				return nil
  2891  			}
  2892  		}
  2893  		file_google_bigtable_v2_data_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
  2894  			switch v := v.(*StreamPartition); i {
  2895  			case 0:
  2896  				return &v.state
  2897  			case 1:
  2898  				return &v.sizeCache
  2899  			case 2:
  2900  				return &v.unknownFields
  2901  			default:
  2902  				return nil
  2903  			}
  2904  		}
  2905  		file_google_bigtable_v2_data_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
  2906  			switch v := v.(*StreamContinuationTokens); i {
  2907  			case 0:
  2908  				return &v.state
  2909  			case 1:
  2910  				return &v.sizeCache
  2911  			case 2:
  2912  				return &v.unknownFields
  2913  			default:
  2914  				return nil
  2915  			}
  2916  		}
  2917  		file_google_bigtable_v2_data_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
  2918  			switch v := v.(*StreamContinuationToken); i {
  2919  			case 0:
  2920  				return &v.state
  2921  			case 1:
  2922  				return &v.sizeCache
  2923  			case 2:
  2924  				return &v.unknownFields
  2925  			default:
  2926  				return nil
  2927  			}
  2928  		}
  2929  		file_google_bigtable_v2_data_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
  2930  			switch v := v.(*RowFilter_Chain); i {
  2931  			case 0:
  2932  				return &v.state
  2933  			case 1:
  2934  				return &v.sizeCache
  2935  			case 2:
  2936  				return &v.unknownFields
  2937  			default:
  2938  				return nil
  2939  			}
  2940  		}
  2941  		file_google_bigtable_v2_data_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
  2942  			switch v := v.(*RowFilter_Interleave); i {
  2943  			case 0:
  2944  				return &v.state
  2945  			case 1:
  2946  				return &v.sizeCache
  2947  			case 2:
  2948  				return &v.unknownFields
  2949  			default:
  2950  				return nil
  2951  			}
  2952  		}
  2953  		file_google_bigtable_v2_data_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
  2954  			switch v := v.(*RowFilter_Condition); i {
  2955  			case 0:
  2956  				return &v.state
  2957  			case 1:
  2958  				return &v.sizeCache
  2959  			case 2:
  2960  				return &v.unknownFields
  2961  			default:
  2962  				return nil
  2963  			}
  2964  		}
  2965  		file_google_bigtable_v2_data_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
  2966  			switch v := v.(*Mutation_SetCell); i {
  2967  			case 0:
  2968  				return &v.state
  2969  			case 1:
  2970  				return &v.sizeCache
  2971  			case 2:
  2972  				return &v.unknownFields
  2973  			default:
  2974  				return nil
  2975  			}
  2976  		}
  2977  		file_google_bigtable_v2_data_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
  2978  			switch v := v.(*Mutation_AddToCell); i {
  2979  			case 0:
  2980  				return &v.state
  2981  			case 1:
  2982  				return &v.sizeCache
  2983  			case 2:
  2984  				return &v.unknownFields
  2985  			default:
  2986  				return nil
  2987  			}
  2988  		}
  2989  		file_google_bigtable_v2_data_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
  2990  			switch v := v.(*Mutation_DeleteFromColumn); i {
  2991  			case 0:
  2992  				return &v.state
  2993  			case 1:
  2994  				return &v.sizeCache
  2995  			case 2:
  2996  				return &v.unknownFields
  2997  			default:
  2998  				return nil
  2999  			}
  3000  		}
  3001  		file_google_bigtable_v2_data_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
  3002  			switch v := v.(*Mutation_DeleteFromFamily); i {
  3003  			case 0:
  3004  				return &v.state
  3005  			case 1:
  3006  				return &v.sizeCache
  3007  			case 2:
  3008  				return &v.unknownFields
  3009  			default:
  3010  				return nil
  3011  			}
  3012  		}
  3013  		file_google_bigtable_v2_data_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
  3014  			switch v := v.(*Mutation_DeleteFromRow); i {
  3015  			case 0:
  3016  				return &v.state
  3017  			case 1:
  3018  				return &v.sizeCache
  3019  			case 2:
  3020  				return &v.unknownFields
  3021  			default:
  3022  				return nil
  3023  			}
  3024  		}
  3025  	}
  3026  	file_google_bigtable_v2_data_proto_msgTypes[4].OneofWrappers = []interface{}{
  3027  		(*Value_RawValue)(nil),
  3028  		(*Value_RawTimestampMicros)(nil),
  3029  		(*Value_IntValue)(nil),
  3030  	}
  3031  	file_google_bigtable_v2_data_proto_msgTypes[5].OneofWrappers = []interface{}{
  3032  		(*RowRange_StartKeyClosed)(nil),
  3033  		(*RowRange_StartKeyOpen)(nil),
  3034  		(*RowRange_EndKeyOpen)(nil),
  3035  		(*RowRange_EndKeyClosed)(nil),
  3036  	}
  3037  	file_google_bigtable_v2_data_proto_msgTypes[7].OneofWrappers = []interface{}{
  3038  		(*ColumnRange_StartQualifierClosed)(nil),
  3039  		(*ColumnRange_StartQualifierOpen)(nil),
  3040  		(*ColumnRange_EndQualifierClosed)(nil),
  3041  		(*ColumnRange_EndQualifierOpen)(nil),
  3042  	}
  3043  	file_google_bigtable_v2_data_proto_msgTypes[9].OneofWrappers = []interface{}{
  3044  		(*ValueRange_StartValueClosed)(nil),
  3045  		(*ValueRange_StartValueOpen)(nil),
  3046  		(*ValueRange_EndValueClosed)(nil),
  3047  		(*ValueRange_EndValueOpen)(nil),
  3048  	}
  3049  	file_google_bigtable_v2_data_proto_msgTypes[10].OneofWrappers = []interface{}{
  3050  		(*RowFilter_Chain_)(nil),
  3051  		(*RowFilter_Interleave_)(nil),
  3052  		(*RowFilter_Condition_)(nil),
  3053  		(*RowFilter_Sink)(nil),
  3054  		(*RowFilter_PassAllFilter)(nil),
  3055  		(*RowFilter_BlockAllFilter)(nil),
  3056  		(*RowFilter_RowKeyRegexFilter)(nil),
  3057  		(*RowFilter_RowSampleFilter)(nil),
  3058  		(*RowFilter_FamilyNameRegexFilter)(nil),
  3059  		(*RowFilter_ColumnQualifierRegexFilter)(nil),
  3060  		(*RowFilter_ColumnRangeFilter)(nil),
  3061  		(*RowFilter_TimestampRangeFilter)(nil),
  3062  		(*RowFilter_ValueRegexFilter)(nil),
  3063  		(*RowFilter_ValueRangeFilter)(nil),
  3064  		(*RowFilter_CellsPerRowOffsetFilter)(nil),
  3065  		(*RowFilter_CellsPerRowLimitFilter)(nil),
  3066  		(*RowFilter_CellsPerColumnLimitFilter)(nil),
  3067  		(*RowFilter_StripValueTransformer)(nil),
  3068  		(*RowFilter_ApplyLabelTransformer)(nil),
  3069  	}
  3070  	file_google_bigtable_v2_data_proto_msgTypes[11].OneofWrappers = []interface{}{
  3071  		(*Mutation_SetCell_)(nil),
  3072  		(*Mutation_AddToCell_)(nil),
  3073  		(*Mutation_DeleteFromColumn_)(nil),
  3074  		(*Mutation_DeleteFromFamily_)(nil),
  3075  		(*Mutation_DeleteFromRow_)(nil),
  3076  	}
  3077  	file_google_bigtable_v2_data_proto_msgTypes[12].OneofWrappers = []interface{}{
  3078  		(*ReadModifyWriteRule_AppendValue)(nil),
  3079  		(*ReadModifyWriteRule_IncrementAmount)(nil),
  3080  	}
  3081  	type x struct{}
  3082  	out := protoimpl.TypeBuilder{
  3083  		File: protoimpl.DescBuilder{
  3084  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  3085  			RawDescriptor: file_google_bigtable_v2_data_proto_rawDesc,
  3086  			NumEnums:      0,
  3087  			NumMessages:   24,
  3088  			NumExtensions: 0,
  3089  			NumServices:   0,
  3090  		},
  3091  		GoTypes:           file_google_bigtable_v2_data_proto_goTypes,
  3092  		DependencyIndexes: file_google_bigtable_v2_data_proto_depIdxs,
  3093  		MessageInfos:      file_google_bigtable_v2_data_proto_msgTypes,
  3094  	}.Build()
  3095  	File_google_bigtable_v2_data_proto = out.File
  3096  	file_google_bigtable_v2_data_proto_rawDesc = nil
  3097  	file_google_bigtable_v2_data_proto_goTypes = nil
  3098  	file_google_bigtable_v2_data_proto_depIdxs = nil
  3099  }
  3100  

View as plain text