Source file src/google.golang.org/genproto/googleapis/bigtable/v1/bigtable_data.pb.go

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

     1  // Copyright 2018 Google Inc.
     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.25.0
    18  // 	protoc        v3.13.0
    19  // source: google/bigtable/v1/bigtable_data.proto
    20  
    21  package bigtable
    22  
    23  import (
    24  	reflect "reflect"
    25  	sync "sync"
    26  
    27  	proto "github.com/golang/protobuf/proto"
    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  // This is a compile-time assertion that a sufficiently up-to-date version
    40  // of the legacy proto package is being used.
    41  const _ = proto.ProtoPackageIsVersion4
    42  
    43  // Specifies the complete (requested) contents of a single row of a table.
    44  // Rows which exceed 256MiB in size cannot be read in full.
    45  type Row struct {
    46  	state         protoimpl.MessageState
    47  	sizeCache     protoimpl.SizeCache
    48  	unknownFields protoimpl.UnknownFields
    49  
    50  	// The unique key which identifies this row within its table. This is the same
    51  	// key that's used to identify the row in, for example, a MutateRowRequest.
    52  	// May contain any non-empty byte string up to 4KiB in length.
    53  	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
    54  	// May be empty, but only if the entire row is empty.
    55  	// The mutual ordering of column families is not specified.
    56  	Families []*Family `protobuf:"bytes,2,rep,name=families,proto3" json:"families,omitempty"`
    57  }
    58  
    59  func (x *Row) Reset() {
    60  	*x = Row{}
    61  	if protoimpl.UnsafeEnabled {
    62  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[0]
    63  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
    64  		ms.StoreMessageInfo(mi)
    65  	}
    66  }
    67  
    68  func (x *Row) String() string {
    69  	return protoimpl.X.MessageStringOf(x)
    70  }
    71  
    72  func (*Row) ProtoMessage() {}
    73  
    74  func (x *Row) ProtoReflect() protoreflect.Message {
    75  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[0]
    76  	if protoimpl.UnsafeEnabled && x != nil {
    77  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
    78  		if ms.LoadMessageInfo() == nil {
    79  			ms.StoreMessageInfo(mi)
    80  		}
    81  		return ms
    82  	}
    83  	return mi.MessageOf(x)
    84  }
    85  
    86  // Deprecated: Use Row.ProtoReflect.Descriptor instead.
    87  func (*Row) Descriptor() ([]byte, []int) {
    88  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{0}
    89  }
    90  
    91  func (x *Row) GetKey() []byte {
    92  	if x != nil {
    93  		return x.Key
    94  	}
    95  	return nil
    96  }
    97  
    98  func (x *Row) GetFamilies() []*Family {
    99  	if x != nil {
   100  		return x.Families
   101  	}
   102  	return nil
   103  }
   104  
   105  // Specifies (some of) the contents of a single row/column family of a table.
   106  type Family struct {
   107  	state         protoimpl.MessageState
   108  	sizeCache     protoimpl.SizeCache
   109  	unknownFields protoimpl.UnknownFields
   110  
   111  	// The unique key which identifies this family within its row. This is the
   112  	// same key that's used to identify the family in, for example, a RowFilter
   113  	// which sets its "family_name_regex_filter" field.
   114  	// Must match [-_.a-zA-Z0-9]+, except that AggregatingRowProcessors may
   115  	// produce cells in a sentinel family with an empty name.
   116  	// Must be no greater than 64 characters in length.
   117  	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
   118  	// Must not be empty. Sorted in order of increasing "qualifier".
   119  	Columns []*Column `protobuf:"bytes,2,rep,name=columns,proto3" json:"columns,omitempty"`
   120  }
   121  
   122  func (x *Family) Reset() {
   123  	*x = Family{}
   124  	if protoimpl.UnsafeEnabled {
   125  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[1]
   126  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   127  		ms.StoreMessageInfo(mi)
   128  	}
   129  }
   130  
   131  func (x *Family) String() string {
   132  	return protoimpl.X.MessageStringOf(x)
   133  }
   134  
   135  func (*Family) ProtoMessage() {}
   136  
   137  func (x *Family) ProtoReflect() protoreflect.Message {
   138  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[1]
   139  	if protoimpl.UnsafeEnabled && x != nil {
   140  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   141  		if ms.LoadMessageInfo() == nil {
   142  			ms.StoreMessageInfo(mi)
   143  		}
   144  		return ms
   145  	}
   146  	return mi.MessageOf(x)
   147  }
   148  
   149  // Deprecated: Use Family.ProtoReflect.Descriptor instead.
   150  func (*Family) Descriptor() ([]byte, []int) {
   151  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{1}
   152  }
   153  
   154  func (x *Family) GetName() string {
   155  	if x != nil {
   156  		return x.Name
   157  	}
   158  	return ""
   159  }
   160  
   161  func (x *Family) GetColumns() []*Column {
   162  	if x != nil {
   163  		return x.Columns
   164  	}
   165  	return nil
   166  }
   167  
   168  // Specifies (some of) the contents of a single row/column of a table.
   169  type Column struct {
   170  	state         protoimpl.MessageState
   171  	sizeCache     protoimpl.SizeCache
   172  	unknownFields protoimpl.UnknownFields
   173  
   174  	// The unique key which identifies this column within its family. This is the
   175  	// same key that's used to identify the column in, for example, a RowFilter
   176  	// which sets its "column_qualifier_regex_filter" field.
   177  	// May contain any byte string, including the empty string, up to 16kiB in
   178  	// length.
   179  	Qualifier []byte `protobuf:"bytes,1,opt,name=qualifier,proto3" json:"qualifier,omitempty"`
   180  	// Must not be empty. Sorted in order of decreasing "timestamp_micros".
   181  	Cells []*Cell `protobuf:"bytes,2,rep,name=cells,proto3" json:"cells,omitempty"`
   182  }
   183  
   184  func (x *Column) Reset() {
   185  	*x = Column{}
   186  	if protoimpl.UnsafeEnabled {
   187  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[2]
   188  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   189  		ms.StoreMessageInfo(mi)
   190  	}
   191  }
   192  
   193  func (x *Column) String() string {
   194  	return protoimpl.X.MessageStringOf(x)
   195  }
   196  
   197  func (*Column) ProtoMessage() {}
   198  
   199  func (x *Column) ProtoReflect() protoreflect.Message {
   200  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[2]
   201  	if protoimpl.UnsafeEnabled && x != nil {
   202  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   203  		if ms.LoadMessageInfo() == nil {
   204  			ms.StoreMessageInfo(mi)
   205  		}
   206  		return ms
   207  	}
   208  	return mi.MessageOf(x)
   209  }
   210  
   211  // Deprecated: Use Column.ProtoReflect.Descriptor instead.
   212  func (*Column) Descriptor() ([]byte, []int) {
   213  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{2}
   214  }
   215  
   216  func (x *Column) GetQualifier() []byte {
   217  	if x != nil {
   218  		return x.Qualifier
   219  	}
   220  	return nil
   221  }
   222  
   223  func (x *Column) GetCells() []*Cell {
   224  	if x != nil {
   225  		return x.Cells
   226  	}
   227  	return nil
   228  }
   229  
   230  // Specifies (some of) the contents of a single row/column/timestamp of a table.
   231  type Cell struct {
   232  	state         protoimpl.MessageState
   233  	sizeCache     protoimpl.SizeCache
   234  	unknownFields protoimpl.UnknownFields
   235  
   236  	// The cell's stored timestamp, which also uniquely identifies it within
   237  	// its column.
   238  	// Values are always expressed in microseconds, but individual tables may set
   239  	// a coarser "granularity" to further restrict the allowed values. For
   240  	// example, a table which specifies millisecond granularity will only allow
   241  	// values of "timestamp_micros" which are multiples of 1000.
   242  	TimestampMicros int64 `protobuf:"varint,1,opt,name=timestamp_micros,json=timestampMicros,proto3" json:"timestamp_micros,omitempty"`
   243  	// The value stored in the cell.
   244  	// May contain any byte string, including the empty string, up to 100MiB in
   245  	// length.
   246  	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
   247  	// Labels applied to the cell by a [RowFilter][google.bigtable.v1.RowFilter].
   248  	Labels []string `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty"`
   249  }
   250  
   251  func (x *Cell) Reset() {
   252  	*x = Cell{}
   253  	if protoimpl.UnsafeEnabled {
   254  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[3]
   255  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   256  		ms.StoreMessageInfo(mi)
   257  	}
   258  }
   259  
   260  func (x *Cell) String() string {
   261  	return protoimpl.X.MessageStringOf(x)
   262  }
   263  
   264  func (*Cell) ProtoMessage() {}
   265  
   266  func (x *Cell) ProtoReflect() protoreflect.Message {
   267  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[3]
   268  	if protoimpl.UnsafeEnabled && x != nil {
   269  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   270  		if ms.LoadMessageInfo() == nil {
   271  			ms.StoreMessageInfo(mi)
   272  		}
   273  		return ms
   274  	}
   275  	return mi.MessageOf(x)
   276  }
   277  
   278  // Deprecated: Use Cell.ProtoReflect.Descriptor instead.
   279  func (*Cell) Descriptor() ([]byte, []int) {
   280  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{3}
   281  }
   282  
   283  func (x *Cell) GetTimestampMicros() int64 {
   284  	if x != nil {
   285  		return x.TimestampMicros
   286  	}
   287  	return 0
   288  }
   289  
   290  func (x *Cell) GetValue() []byte {
   291  	if x != nil {
   292  		return x.Value
   293  	}
   294  	return nil
   295  }
   296  
   297  func (x *Cell) GetLabels() []string {
   298  	if x != nil {
   299  		return x.Labels
   300  	}
   301  	return nil
   302  }
   303  
   304  // Specifies a contiguous range of rows.
   305  type RowRange struct {
   306  	state         protoimpl.MessageState
   307  	sizeCache     protoimpl.SizeCache
   308  	unknownFields protoimpl.UnknownFields
   309  
   310  	// Inclusive lower bound. If left empty, interpreted as the empty string.
   311  	StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"`
   312  	// Exclusive upper bound. If left empty, interpreted as infinity.
   313  	EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"`
   314  }
   315  
   316  func (x *RowRange) Reset() {
   317  	*x = RowRange{}
   318  	if protoimpl.UnsafeEnabled {
   319  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[4]
   320  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   321  		ms.StoreMessageInfo(mi)
   322  	}
   323  }
   324  
   325  func (x *RowRange) String() string {
   326  	return protoimpl.X.MessageStringOf(x)
   327  }
   328  
   329  func (*RowRange) ProtoMessage() {}
   330  
   331  func (x *RowRange) ProtoReflect() protoreflect.Message {
   332  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[4]
   333  	if protoimpl.UnsafeEnabled && x != nil {
   334  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   335  		if ms.LoadMessageInfo() == nil {
   336  			ms.StoreMessageInfo(mi)
   337  		}
   338  		return ms
   339  	}
   340  	return mi.MessageOf(x)
   341  }
   342  
   343  // Deprecated: Use RowRange.ProtoReflect.Descriptor instead.
   344  func (*RowRange) Descriptor() ([]byte, []int) {
   345  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{4}
   346  }
   347  
   348  func (x *RowRange) GetStartKey() []byte {
   349  	if x != nil {
   350  		return x.StartKey
   351  	}
   352  	return nil
   353  }
   354  
   355  func (x *RowRange) GetEndKey() []byte {
   356  	if x != nil {
   357  		return x.EndKey
   358  	}
   359  	return nil
   360  }
   361  
   362  // Specifies a non-contiguous set of rows.
   363  type RowSet struct {
   364  	state         protoimpl.MessageState
   365  	sizeCache     protoimpl.SizeCache
   366  	unknownFields protoimpl.UnknownFields
   367  
   368  	// Single rows included in the set.
   369  	RowKeys [][]byte `protobuf:"bytes,1,rep,name=row_keys,json=rowKeys,proto3" json:"row_keys,omitempty"`
   370  	// Contiguous row ranges included in the set.
   371  	RowRanges []*RowRange `protobuf:"bytes,2,rep,name=row_ranges,json=rowRanges,proto3" json:"row_ranges,omitempty"`
   372  }
   373  
   374  func (x *RowSet) Reset() {
   375  	*x = RowSet{}
   376  	if protoimpl.UnsafeEnabled {
   377  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[5]
   378  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   379  		ms.StoreMessageInfo(mi)
   380  	}
   381  }
   382  
   383  func (x *RowSet) String() string {
   384  	return protoimpl.X.MessageStringOf(x)
   385  }
   386  
   387  func (*RowSet) ProtoMessage() {}
   388  
   389  func (x *RowSet) ProtoReflect() protoreflect.Message {
   390  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[5]
   391  	if protoimpl.UnsafeEnabled && x != nil {
   392  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   393  		if ms.LoadMessageInfo() == nil {
   394  			ms.StoreMessageInfo(mi)
   395  		}
   396  		return ms
   397  	}
   398  	return mi.MessageOf(x)
   399  }
   400  
   401  // Deprecated: Use RowSet.ProtoReflect.Descriptor instead.
   402  func (*RowSet) Descriptor() ([]byte, []int) {
   403  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{5}
   404  }
   405  
   406  func (x *RowSet) GetRowKeys() [][]byte {
   407  	if x != nil {
   408  		return x.RowKeys
   409  	}
   410  	return nil
   411  }
   412  
   413  func (x *RowSet) GetRowRanges() []*RowRange {
   414  	if x != nil {
   415  		return x.RowRanges
   416  	}
   417  	return nil
   418  }
   419  
   420  // Specifies a contiguous range of columns within a single column family.
   421  // The range spans from <column_family>:<start_qualifier> to
   422  // <column_family>:<end_qualifier>, where both bounds can be either inclusive or
   423  // exclusive.
   424  type ColumnRange struct {
   425  	state         protoimpl.MessageState
   426  	sizeCache     protoimpl.SizeCache
   427  	unknownFields protoimpl.UnknownFields
   428  
   429  	// The name of the column family within which this range falls.
   430  	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
   431  	// The column qualifier at which to start the range (within 'column_family').
   432  	// If neither field is set, interpreted as the empty string, inclusive.
   433  	//
   434  	// Types that are assignable to StartQualifier:
   435  	//	*ColumnRange_StartQualifierInclusive
   436  	//	*ColumnRange_StartQualifierExclusive
   437  	StartQualifier isColumnRange_StartQualifier `protobuf_oneof:"start_qualifier"`
   438  	// The column qualifier at which to end the range (within 'column_family').
   439  	// If neither field is set, interpreted as the infinite string, exclusive.
   440  	//
   441  	// Types that are assignable to EndQualifier:
   442  	//	*ColumnRange_EndQualifierInclusive
   443  	//	*ColumnRange_EndQualifierExclusive
   444  	EndQualifier isColumnRange_EndQualifier `protobuf_oneof:"end_qualifier"`
   445  }
   446  
   447  func (x *ColumnRange) Reset() {
   448  	*x = ColumnRange{}
   449  	if protoimpl.UnsafeEnabled {
   450  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[6]
   451  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   452  		ms.StoreMessageInfo(mi)
   453  	}
   454  }
   455  
   456  func (x *ColumnRange) String() string {
   457  	return protoimpl.X.MessageStringOf(x)
   458  }
   459  
   460  func (*ColumnRange) ProtoMessage() {}
   461  
   462  func (x *ColumnRange) ProtoReflect() protoreflect.Message {
   463  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[6]
   464  	if protoimpl.UnsafeEnabled && x != nil {
   465  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   466  		if ms.LoadMessageInfo() == nil {
   467  			ms.StoreMessageInfo(mi)
   468  		}
   469  		return ms
   470  	}
   471  	return mi.MessageOf(x)
   472  }
   473  
   474  // Deprecated: Use ColumnRange.ProtoReflect.Descriptor instead.
   475  func (*ColumnRange) Descriptor() ([]byte, []int) {
   476  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{6}
   477  }
   478  
   479  func (x *ColumnRange) GetFamilyName() string {
   480  	if x != nil {
   481  		return x.FamilyName
   482  	}
   483  	return ""
   484  }
   485  
   486  func (m *ColumnRange) GetStartQualifier() isColumnRange_StartQualifier {
   487  	if m != nil {
   488  		return m.StartQualifier
   489  	}
   490  	return nil
   491  }
   492  
   493  func (x *ColumnRange) GetStartQualifierInclusive() []byte {
   494  	if x, ok := x.GetStartQualifier().(*ColumnRange_StartQualifierInclusive); ok {
   495  		return x.StartQualifierInclusive
   496  	}
   497  	return nil
   498  }
   499  
   500  func (x *ColumnRange) GetStartQualifierExclusive() []byte {
   501  	if x, ok := x.GetStartQualifier().(*ColumnRange_StartQualifierExclusive); ok {
   502  		return x.StartQualifierExclusive
   503  	}
   504  	return nil
   505  }
   506  
   507  func (m *ColumnRange) GetEndQualifier() isColumnRange_EndQualifier {
   508  	if m != nil {
   509  		return m.EndQualifier
   510  	}
   511  	return nil
   512  }
   513  
   514  func (x *ColumnRange) GetEndQualifierInclusive() []byte {
   515  	if x, ok := x.GetEndQualifier().(*ColumnRange_EndQualifierInclusive); ok {
   516  		return x.EndQualifierInclusive
   517  	}
   518  	return nil
   519  }
   520  
   521  func (x *ColumnRange) GetEndQualifierExclusive() []byte {
   522  	if x, ok := x.GetEndQualifier().(*ColumnRange_EndQualifierExclusive); ok {
   523  		return x.EndQualifierExclusive
   524  	}
   525  	return nil
   526  }
   527  
   528  type isColumnRange_StartQualifier interface {
   529  	isColumnRange_StartQualifier()
   530  }
   531  
   532  type ColumnRange_StartQualifierInclusive struct {
   533  	// Used when giving an inclusive lower bound for the range.
   534  	StartQualifierInclusive []byte `protobuf:"bytes,2,opt,name=start_qualifier_inclusive,json=startQualifierInclusive,proto3,oneof"`
   535  }
   536  
   537  type ColumnRange_StartQualifierExclusive struct {
   538  	// Used when giving an exclusive lower bound for the range.
   539  	StartQualifierExclusive []byte `protobuf:"bytes,3,opt,name=start_qualifier_exclusive,json=startQualifierExclusive,proto3,oneof"`
   540  }
   541  
   542  func (*ColumnRange_StartQualifierInclusive) isColumnRange_StartQualifier() {}
   543  
   544  func (*ColumnRange_StartQualifierExclusive) isColumnRange_StartQualifier() {}
   545  
   546  type isColumnRange_EndQualifier interface {
   547  	isColumnRange_EndQualifier()
   548  }
   549  
   550  type ColumnRange_EndQualifierInclusive struct {
   551  	// Used when giving an inclusive upper bound for the range.
   552  	EndQualifierInclusive []byte `protobuf:"bytes,4,opt,name=end_qualifier_inclusive,json=endQualifierInclusive,proto3,oneof"`
   553  }
   554  
   555  type ColumnRange_EndQualifierExclusive struct {
   556  	// Used when giving an exclusive upper bound for the range.
   557  	EndQualifierExclusive []byte `protobuf:"bytes,5,opt,name=end_qualifier_exclusive,json=endQualifierExclusive,proto3,oneof"`
   558  }
   559  
   560  func (*ColumnRange_EndQualifierInclusive) isColumnRange_EndQualifier() {}
   561  
   562  func (*ColumnRange_EndQualifierExclusive) isColumnRange_EndQualifier() {}
   563  
   564  // Specified a contiguous range of microsecond timestamps.
   565  type TimestampRange struct {
   566  	state         protoimpl.MessageState
   567  	sizeCache     protoimpl.SizeCache
   568  	unknownFields protoimpl.UnknownFields
   569  
   570  	// Inclusive lower bound. If left empty, interpreted as 0.
   571  	StartTimestampMicros int64 `protobuf:"varint,1,opt,name=start_timestamp_micros,json=startTimestampMicros,proto3" json:"start_timestamp_micros,omitempty"`
   572  	// Exclusive upper bound. If left empty, interpreted as infinity.
   573  	EndTimestampMicros int64 `protobuf:"varint,2,opt,name=end_timestamp_micros,json=endTimestampMicros,proto3" json:"end_timestamp_micros,omitempty"`
   574  }
   575  
   576  func (x *TimestampRange) Reset() {
   577  	*x = TimestampRange{}
   578  	if protoimpl.UnsafeEnabled {
   579  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[7]
   580  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   581  		ms.StoreMessageInfo(mi)
   582  	}
   583  }
   584  
   585  func (x *TimestampRange) String() string {
   586  	return protoimpl.X.MessageStringOf(x)
   587  }
   588  
   589  func (*TimestampRange) ProtoMessage() {}
   590  
   591  func (x *TimestampRange) ProtoReflect() protoreflect.Message {
   592  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[7]
   593  	if protoimpl.UnsafeEnabled && x != nil {
   594  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   595  		if ms.LoadMessageInfo() == nil {
   596  			ms.StoreMessageInfo(mi)
   597  		}
   598  		return ms
   599  	}
   600  	return mi.MessageOf(x)
   601  }
   602  
   603  // Deprecated: Use TimestampRange.ProtoReflect.Descriptor instead.
   604  func (*TimestampRange) Descriptor() ([]byte, []int) {
   605  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{7}
   606  }
   607  
   608  func (x *TimestampRange) GetStartTimestampMicros() int64 {
   609  	if x != nil {
   610  		return x.StartTimestampMicros
   611  	}
   612  	return 0
   613  }
   614  
   615  func (x *TimestampRange) GetEndTimestampMicros() int64 {
   616  	if x != nil {
   617  		return x.EndTimestampMicros
   618  	}
   619  	return 0
   620  }
   621  
   622  // Specifies a contiguous range of raw byte values.
   623  type ValueRange struct {
   624  	state         protoimpl.MessageState
   625  	sizeCache     protoimpl.SizeCache
   626  	unknownFields protoimpl.UnknownFields
   627  
   628  	// The value at which to start the range.
   629  	// If neither field is set, interpreted as the empty string, inclusive.
   630  	//
   631  	// Types that are assignable to StartValue:
   632  	//	*ValueRange_StartValueInclusive
   633  	//	*ValueRange_StartValueExclusive
   634  	StartValue isValueRange_StartValue `protobuf_oneof:"start_value"`
   635  	// The value at which to end the range.
   636  	// If neither field is set, interpreted as the infinite string, exclusive.
   637  	//
   638  	// Types that are assignable to EndValue:
   639  	//	*ValueRange_EndValueInclusive
   640  	//	*ValueRange_EndValueExclusive
   641  	EndValue isValueRange_EndValue `protobuf_oneof:"end_value"`
   642  }
   643  
   644  func (x *ValueRange) Reset() {
   645  	*x = ValueRange{}
   646  	if protoimpl.UnsafeEnabled {
   647  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[8]
   648  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   649  		ms.StoreMessageInfo(mi)
   650  	}
   651  }
   652  
   653  func (x *ValueRange) String() string {
   654  	return protoimpl.X.MessageStringOf(x)
   655  }
   656  
   657  func (*ValueRange) ProtoMessage() {}
   658  
   659  func (x *ValueRange) ProtoReflect() protoreflect.Message {
   660  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[8]
   661  	if protoimpl.UnsafeEnabled && x != nil {
   662  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   663  		if ms.LoadMessageInfo() == nil {
   664  			ms.StoreMessageInfo(mi)
   665  		}
   666  		return ms
   667  	}
   668  	return mi.MessageOf(x)
   669  }
   670  
   671  // Deprecated: Use ValueRange.ProtoReflect.Descriptor instead.
   672  func (*ValueRange) Descriptor() ([]byte, []int) {
   673  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{8}
   674  }
   675  
   676  func (m *ValueRange) GetStartValue() isValueRange_StartValue {
   677  	if m != nil {
   678  		return m.StartValue
   679  	}
   680  	return nil
   681  }
   682  
   683  func (x *ValueRange) GetStartValueInclusive() []byte {
   684  	if x, ok := x.GetStartValue().(*ValueRange_StartValueInclusive); ok {
   685  		return x.StartValueInclusive
   686  	}
   687  	return nil
   688  }
   689  
   690  func (x *ValueRange) GetStartValueExclusive() []byte {
   691  	if x, ok := x.GetStartValue().(*ValueRange_StartValueExclusive); ok {
   692  		return x.StartValueExclusive
   693  	}
   694  	return nil
   695  }
   696  
   697  func (m *ValueRange) GetEndValue() isValueRange_EndValue {
   698  	if m != nil {
   699  		return m.EndValue
   700  	}
   701  	return nil
   702  }
   703  
   704  func (x *ValueRange) GetEndValueInclusive() []byte {
   705  	if x, ok := x.GetEndValue().(*ValueRange_EndValueInclusive); ok {
   706  		return x.EndValueInclusive
   707  	}
   708  	return nil
   709  }
   710  
   711  func (x *ValueRange) GetEndValueExclusive() []byte {
   712  	if x, ok := x.GetEndValue().(*ValueRange_EndValueExclusive); ok {
   713  		return x.EndValueExclusive
   714  	}
   715  	return nil
   716  }
   717  
   718  type isValueRange_StartValue interface {
   719  	isValueRange_StartValue()
   720  }
   721  
   722  type ValueRange_StartValueInclusive struct {
   723  	// Used when giving an inclusive lower bound for the range.
   724  	StartValueInclusive []byte `protobuf:"bytes,1,opt,name=start_value_inclusive,json=startValueInclusive,proto3,oneof"`
   725  }
   726  
   727  type ValueRange_StartValueExclusive struct {
   728  	// Used when giving an exclusive lower bound for the range.
   729  	StartValueExclusive []byte `protobuf:"bytes,2,opt,name=start_value_exclusive,json=startValueExclusive,proto3,oneof"`
   730  }
   731  
   732  func (*ValueRange_StartValueInclusive) isValueRange_StartValue() {}
   733  
   734  func (*ValueRange_StartValueExclusive) isValueRange_StartValue() {}
   735  
   736  type isValueRange_EndValue interface {
   737  	isValueRange_EndValue()
   738  }
   739  
   740  type ValueRange_EndValueInclusive struct {
   741  	// Used when giving an inclusive upper bound for the range.
   742  	EndValueInclusive []byte `protobuf:"bytes,3,opt,name=end_value_inclusive,json=endValueInclusive,proto3,oneof"`
   743  }
   744  
   745  type ValueRange_EndValueExclusive struct {
   746  	// Used when giving an exclusive upper bound for the range.
   747  	EndValueExclusive []byte `protobuf:"bytes,4,opt,name=end_value_exclusive,json=endValueExclusive,proto3,oneof"`
   748  }
   749  
   750  func (*ValueRange_EndValueInclusive) isValueRange_EndValue() {}
   751  
   752  func (*ValueRange_EndValueExclusive) isValueRange_EndValue() {}
   753  
   754  // Takes a row as input and produces an alternate view of the row based on
   755  // specified rules. For example, a RowFilter might trim down a row to include
   756  // just the cells from columns matching a given regular expression, or might
   757  // return all the cells of a row but not their values. More complicated filters
   758  // can be composed out of these components to express requests such as, "within
   759  // every column of a particular family, give just the two most recent cells
   760  // which are older than timestamp X."
   761  //
   762  // There are two broad categories of RowFilters (true filters and transformers),
   763  // as well as two ways to compose simple filters into more complex ones
   764  // (chains and interleaves). They work as follows:
   765  //
   766  // * True filters alter the input row by excluding some of its cells wholesale
   767  // from the output row. An example of a true filter is the "value_regex_filter",
   768  // which excludes cells whose values don't match the specified pattern. All
   769  // regex true filters use RE2 syntax (https://github.com/google/re2/wiki/Syntax)
   770  // in raw byte mode (RE2::Latin1), and are evaluated as full matches. An
   771  // important point to keep in mind is that RE2(.) is equivalent by default to
   772  // RE2([^\n]), meaning that it does not match newlines. When attempting to match
   773  // an arbitrary byte, you should therefore use the escape sequence '\C', which
   774  // may need to be further escaped as '\\C' in your client language.
   775  //
   776  // * Transformers alter the input row by changing the values of some of its
   777  // cells in the output, without excluding them completely. Currently, the only
   778  // supported transformer is the "strip_value_transformer", which replaces every
   779  // cell's value with the empty string.
   780  //
   781  // * Chains and interleaves are described in more detail in the
   782  // RowFilter.Chain and RowFilter.Interleave documentation.
   783  //
   784  // The total serialized size of a RowFilter message must not
   785  // exceed 4096 bytes, and RowFilters may not be nested within each other
   786  // (in Chains or Interleaves) to a depth of more than 20.
   787  type RowFilter struct {
   788  	state         protoimpl.MessageState
   789  	sizeCache     protoimpl.SizeCache
   790  	unknownFields protoimpl.UnknownFields
   791  
   792  	// Which of the possible RowFilter types to apply. If none are set, this
   793  	// RowFilter returns all cells in the input row.
   794  	//
   795  	// Types that are assignable to Filter:
   796  	//	*RowFilter_Chain_
   797  	//	*RowFilter_Interleave_
   798  	//	*RowFilter_Condition_
   799  	//	*RowFilter_Sink
   800  	//	*RowFilter_PassAllFilter
   801  	//	*RowFilter_BlockAllFilter
   802  	//	*RowFilter_RowKeyRegexFilter
   803  	//	*RowFilter_RowSampleFilter
   804  	//	*RowFilter_FamilyNameRegexFilter
   805  	//	*RowFilter_ColumnQualifierRegexFilter
   806  	//	*RowFilter_ColumnRangeFilter
   807  	//	*RowFilter_TimestampRangeFilter
   808  	//	*RowFilter_ValueRegexFilter
   809  	//	*RowFilter_ValueRangeFilter
   810  	//	*RowFilter_CellsPerRowOffsetFilter
   811  	//	*RowFilter_CellsPerRowLimitFilter
   812  	//	*RowFilter_CellsPerColumnLimitFilter
   813  	//	*RowFilter_StripValueTransformer
   814  	//	*RowFilter_ApplyLabelTransformer
   815  	Filter isRowFilter_Filter `protobuf_oneof:"filter"`
   816  }
   817  
   818  func (x *RowFilter) Reset() {
   819  	*x = RowFilter{}
   820  	if protoimpl.UnsafeEnabled {
   821  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[9]
   822  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   823  		ms.StoreMessageInfo(mi)
   824  	}
   825  }
   826  
   827  func (x *RowFilter) String() string {
   828  	return protoimpl.X.MessageStringOf(x)
   829  }
   830  
   831  func (*RowFilter) ProtoMessage() {}
   832  
   833  func (x *RowFilter) ProtoReflect() protoreflect.Message {
   834  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[9]
   835  	if protoimpl.UnsafeEnabled && x != nil {
   836  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
   837  		if ms.LoadMessageInfo() == nil {
   838  			ms.StoreMessageInfo(mi)
   839  		}
   840  		return ms
   841  	}
   842  	return mi.MessageOf(x)
   843  }
   844  
   845  // Deprecated: Use RowFilter.ProtoReflect.Descriptor instead.
   846  func (*RowFilter) Descriptor() ([]byte, []int) {
   847  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{9}
   848  }
   849  
   850  func (m *RowFilter) GetFilter() isRowFilter_Filter {
   851  	if m != nil {
   852  		return m.Filter
   853  	}
   854  	return nil
   855  }
   856  
   857  func (x *RowFilter) GetChain() *RowFilter_Chain {
   858  	if x, ok := x.GetFilter().(*RowFilter_Chain_); ok {
   859  		return x.Chain
   860  	}
   861  	return nil
   862  }
   863  
   864  func (x *RowFilter) GetInterleave() *RowFilter_Interleave {
   865  	if x, ok := x.GetFilter().(*RowFilter_Interleave_); ok {
   866  		return x.Interleave
   867  	}
   868  	return nil
   869  }
   870  
   871  func (x *RowFilter) GetCondition() *RowFilter_Condition {
   872  	if x, ok := x.GetFilter().(*RowFilter_Condition_); ok {
   873  		return x.Condition
   874  	}
   875  	return nil
   876  }
   877  
   878  func (x *RowFilter) GetSink() bool {
   879  	if x, ok := x.GetFilter().(*RowFilter_Sink); ok {
   880  		return x.Sink
   881  	}
   882  	return false
   883  }
   884  
   885  func (x *RowFilter) GetPassAllFilter() bool {
   886  	if x, ok := x.GetFilter().(*RowFilter_PassAllFilter); ok {
   887  		return x.PassAllFilter
   888  	}
   889  	return false
   890  }
   891  
   892  func (x *RowFilter) GetBlockAllFilter() bool {
   893  	if x, ok := x.GetFilter().(*RowFilter_BlockAllFilter); ok {
   894  		return x.BlockAllFilter
   895  	}
   896  	return false
   897  }
   898  
   899  func (x *RowFilter) GetRowKeyRegexFilter() []byte {
   900  	if x, ok := x.GetFilter().(*RowFilter_RowKeyRegexFilter); ok {
   901  		return x.RowKeyRegexFilter
   902  	}
   903  	return nil
   904  }
   905  
   906  func (x *RowFilter) GetRowSampleFilter() float64 {
   907  	if x, ok := x.GetFilter().(*RowFilter_RowSampleFilter); ok {
   908  		return x.RowSampleFilter
   909  	}
   910  	return 0
   911  }
   912  
   913  func (x *RowFilter) GetFamilyNameRegexFilter() string {
   914  	if x, ok := x.GetFilter().(*RowFilter_FamilyNameRegexFilter); ok {
   915  		return x.FamilyNameRegexFilter
   916  	}
   917  	return ""
   918  }
   919  
   920  func (x *RowFilter) GetColumnQualifierRegexFilter() []byte {
   921  	if x, ok := x.GetFilter().(*RowFilter_ColumnQualifierRegexFilter); ok {
   922  		return x.ColumnQualifierRegexFilter
   923  	}
   924  	return nil
   925  }
   926  
   927  func (x *RowFilter) GetColumnRangeFilter() *ColumnRange {
   928  	if x, ok := x.GetFilter().(*RowFilter_ColumnRangeFilter); ok {
   929  		return x.ColumnRangeFilter
   930  	}
   931  	return nil
   932  }
   933  
   934  func (x *RowFilter) GetTimestampRangeFilter() *TimestampRange {
   935  	if x, ok := x.GetFilter().(*RowFilter_TimestampRangeFilter); ok {
   936  		return x.TimestampRangeFilter
   937  	}
   938  	return nil
   939  }
   940  
   941  func (x *RowFilter) GetValueRegexFilter() []byte {
   942  	if x, ok := x.GetFilter().(*RowFilter_ValueRegexFilter); ok {
   943  		return x.ValueRegexFilter
   944  	}
   945  	return nil
   946  }
   947  
   948  func (x *RowFilter) GetValueRangeFilter() *ValueRange {
   949  	if x, ok := x.GetFilter().(*RowFilter_ValueRangeFilter); ok {
   950  		return x.ValueRangeFilter
   951  	}
   952  	return nil
   953  }
   954  
   955  func (x *RowFilter) GetCellsPerRowOffsetFilter() int32 {
   956  	if x, ok := x.GetFilter().(*RowFilter_CellsPerRowOffsetFilter); ok {
   957  		return x.CellsPerRowOffsetFilter
   958  	}
   959  	return 0
   960  }
   961  
   962  func (x *RowFilter) GetCellsPerRowLimitFilter() int32 {
   963  	if x, ok := x.GetFilter().(*RowFilter_CellsPerRowLimitFilter); ok {
   964  		return x.CellsPerRowLimitFilter
   965  	}
   966  	return 0
   967  }
   968  
   969  func (x *RowFilter) GetCellsPerColumnLimitFilter() int32 {
   970  	if x, ok := x.GetFilter().(*RowFilter_CellsPerColumnLimitFilter); ok {
   971  		return x.CellsPerColumnLimitFilter
   972  	}
   973  	return 0
   974  }
   975  
   976  func (x *RowFilter) GetStripValueTransformer() bool {
   977  	if x, ok := x.GetFilter().(*RowFilter_StripValueTransformer); ok {
   978  		return x.StripValueTransformer
   979  	}
   980  	return false
   981  }
   982  
   983  func (x *RowFilter) GetApplyLabelTransformer() string {
   984  	if x, ok := x.GetFilter().(*RowFilter_ApplyLabelTransformer); ok {
   985  		return x.ApplyLabelTransformer
   986  	}
   987  	return ""
   988  }
   989  
   990  type isRowFilter_Filter interface {
   991  	isRowFilter_Filter()
   992  }
   993  
   994  type RowFilter_Chain_ struct {
   995  	// Applies several RowFilters to the data in sequence, progressively
   996  	// narrowing the results.
   997  	Chain *RowFilter_Chain `protobuf:"bytes,1,opt,name=chain,proto3,oneof"`
   998  }
   999  
  1000  type RowFilter_Interleave_ struct {
  1001  	// Applies several RowFilters to the data in parallel and combines the
  1002  	// results.
  1003  	Interleave *RowFilter_Interleave `protobuf:"bytes,2,opt,name=interleave,proto3,oneof"`
  1004  }
  1005  
  1006  type RowFilter_Condition_ struct {
  1007  	// Applies one of two possible RowFilters to the data based on the output of
  1008  	// a predicate RowFilter.
  1009  	Condition *RowFilter_Condition `protobuf:"bytes,3,opt,name=condition,proto3,oneof"`
  1010  }
  1011  
  1012  type RowFilter_Sink struct {
  1013  	// ADVANCED USE ONLY.
  1014  	// Hook for introspection into the RowFilter. Outputs all cells directly to
  1015  	// the output of the read rather than to any parent filter. Consider the
  1016  	// following example:
  1017  	//
  1018  	// Chain(
  1019  	//   FamilyRegex("A"),
  1020  	//   Interleave(
  1021  	//     All(),
  1022  	//     Chain(Label("foo"), Sink())
  1023  	//   ),
  1024  	//   QualifierRegex("B")
  1025  	// )
  1026  	//
  1027  	//                         A,A,1,w
  1028  	//                         A,B,2,x
  1029  	//                         B,B,4,z
  1030  	//                            |
  1031  	//                     FamilyRegex("A")
  1032  	//                            |
  1033  	//                         A,A,1,w
  1034  	//                         A,B,2,x
  1035  	//                            |
  1036  	//               +------------+-------------+
  1037  	//               |                          |
  1038  	//             All()                    Label(foo)
  1039  	//               |                          |
  1040  	//            A,A,1,w              A,A,1,w,labels:[foo]
  1041  	//            A,B,2,x              A,B,2,x,labels:[foo]
  1042  	//               |                          |
  1043  	//               |                        Sink() --------------+
  1044  	//               |                          |                  |
  1045  	//               +------------+      x------+          A,A,1,w,labels:[foo]
  1046  	//                            |                        A,B,2,x,labels:[foo]
  1047  	//                         A,A,1,w                             |
  1048  	//                         A,B,2,x                             |
  1049  	//                            |                                |
  1050  	//                    QualifierRegex("B")                      |
  1051  	//                            |                                |
  1052  	//                         A,B,2,x                             |
  1053  	//                            |                                |
  1054  	//                            +--------------------------------+
  1055  	//                            |
  1056  	//                         A,A,1,w,labels:[foo]
  1057  	//                         A,B,2,x,labels:[foo]  // could be switched
  1058  	//                         A,B,2,x               // could be switched
  1059  	//
  1060  	// Despite being excluded by the qualifier filter, a copy of every cell
  1061  	// that reaches the sink is present in the final result.
  1062  	//
  1063  	// As with an [Interleave][google.bigtable.v1.RowFilter.Interleave],
  1064  	// duplicate cells are possible, and appear in an unspecified mutual order.
  1065  	// In this case we have a duplicate with column "A:B" and timestamp 2,
  1066  	// because one copy passed through the all filter while the other was
  1067  	// passed through the label and sink. Note that one copy has label "foo",
  1068  	// while the other does not.
  1069  	//
  1070  	// Cannot be used within the `predicate_filter`, `true_filter`, or
  1071  	// `false_filter` of a [Condition][google.bigtable.v1.RowFilter.Condition].
  1072  	Sink bool `protobuf:"varint,16,opt,name=sink,proto3,oneof"`
  1073  }
  1074  
  1075  type RowFilter_PassAllFilter struct {
  1076  	// Matches all cells, regardless of input. Functionally equivalent to
  1077  	// leaving `filter` unset, but included for completeness.
  1078  	PassAllFilter bool `protobuf:"varint,17,opt,name=pass_all_filter,json=passAllFilter,proto3,oneof"`
  1079  }
  1080  
  1081  type RowFilter_BlockAllFilter struct {
  1082  	// Does not match any cells, regardless of input. Useful for temporarily
  1083  	// disabling just part of a filter.
  1084  	BlockAllFilter bool `protobuf:"varint,18,opt,name=block_all_filter,json=blockAllFilter,proto3,oneof"`
  1085  }
  1086  
  1087  type RowFilter_RowKeyRegexFilter struct {
  1088  	// Matches only cells from rows whose keys satisfy the given RE2 regex. In
  1089  	// other words, passes through the entire row when the key matches, and
  1090  	// otherwise produces an empty row.
  1091  	// Note that, since row keys can contain arbitrary bytes, the '\C' escape
  1092  	// sequence must be used if a true wildcard is desired. The '.' character
  1093  	// will not match the new line character '\n', which may be present in a
  1094  	// binary key.
  1095  	RowKeyRegexFilter []byte `protobuf:"bytes,4,opt,name=row_key_regex_filter,json=rowKeyRegexFilter,proto3,oneof"`
  1096  }
  1097  
  1098  type RowFilter_RowSampleFilter struct {
  1099  	// Matches all cells from a row with probability p, and matches no cells
  1100  	// from the row with probability 1-p.
  1101  	RowSampleFilter float64 `protobuf:"fixed64,14,opt,name=row_sample_filter,json=rowSampleFilter,proto3,oneof"`
  1102  }
  1103  
  1104  type RowFilter_FamilyNameRegexFilter struct {
  1105  	// Matches only cells from columns whose families satisfy the given RE2
  1106  	// regex. For technical reasons, the regex must not contain the ':'
  1107  	// character, even if it is not being used as a literal.
  1108  	// Note that, since column families cannot contain the new line character
  1109  	// '\n', it is sufficient to use '.' as a full wildcard when matching
  1110  	// column family names.
  1111  	FamilyNameRegexFilter string `protobuf:"bytes,5,opt,name=family_name_regex_filter,json=familyNameRegexFilter,proto3,oneof"`
  1112  }
  1113  
  1114  type RowFilter_ColumnQualifierRegexFilter struct {
  1115  	// Matches only cells from columns whose qualifiers satisfy the given RE2
  1116  	// regex.
  1117  	// Note that, since column qualifiers can contain arbitrary bytes, the '\C'
  1118  	// escape sequence must be used if a true wildcard is desired. The '.'
  1119  	// character will not match the new line character '\n', which may be
  1120  	// present in a binary qualifier.
  1121  	ColumnQualifierRegexFilter []byte `protobuf:"bytes,6,opt,name=column_qualifier_regex_filter,json=columnQualifierRegexFilter,proto3,oneof"`
  1122  }
  1123  
  1124  type RowFilter_ColumnRangeFilter struct {
  1125  	// Matches only cells from columns within the given range.
  1126  	ColumnRangeFilter *ColumnRange `protobuf:"bytes,7,opt,name=column_range_filter,json=columnRangeFilter,proto3,oneof"`
  1127  }
  1128  
  1129  type RowFilter_TimestampRangeFilter struct {
  1130  	// Matches only cells with timestamps within the given range.
  1131  	TimestampRangeFilter *TimestampRange `protobuf:"bytes,8,opt,name=timestamp_range_filter,json=timestampRangeFilter,proto3,oneof"`
  1132  }
  1133  
  1134  type RowFilter_ValueRegexFilter struct {
  1135  	// Matches only cells with values that satisfy the given regular expression.
  1136  	// Note that, since cell values can contain arbitrary bytes, the '\C' escape
  1137  	// sequence must be used if a true wildcard is desired. The '.' character
  1138  	// will not match the new line character '\n', which may be present in a
  1139  	// binary value.
  1140  	ValueRegexFilter []byte `protobuf:"bytes,9,opt,name=value_regex_filter,json=valueRegexFilter,proto3,oneof"`
  1141  }
  1142  
  1143  type RowFilter_ValueRangeFilter struct {
  1144  	// Matches only cells with values that fall within the given range.
  1145  	ValueRangeFilter *ValueRange `protobuf:"bytes,15,opt,name=value_range_filter,json=valueRangeFilter,proto3,oneof"`
  1146  }
  1147  
  1148  type RowFilter_CellsPerRowOffsetFilter struct {
  1149  	// Skips the first N cells of each row, matching all subsequent cells.
  1150  	// If duplicate cells are present, as is possible when using an Interleave,
  1151  	// each copy of the cell is counted separately.
  1152  	CellsPerRowOffsetFilter int32 `protobuf:"varint,10,opt,name=cells_per_row_offset_filter,json=cellsPerRowOffsetFilter,proto3,oneof"`
  1153  }
  1154  
  1155  type RowFilter_CellsPerRowLimitFilter struct {
  1156  	// Matches only the first N cells of each row.
  1157  	// If duplicate cells are present, as is possible when using an Interleave,
  1158  	// each copy of the cell is counted separately.
  1159  	CellsPerRowLimitFilter int32 `protobuf:"varint,11,opt,name=cells_per_row_limit_filter,json=cellsPerRowLimitFilter,proto3,oneof"`
  1160  }
  1161  
  1162  type RowFilter_CellsPerColumnLimitFilter struct {
  1163  	// Matches only the most recent N cells within each column. For example,
  1164  	// if N=2, this filter would match column "foo:bar" at timestamps 10 and 9,
  1165  	// skip all earlier cells in "foo:bar", and then begin matching again in
  1166  	// column "foo:bar2".
  1167  	// If duplicate cells are present, as is possible when using an Interleave,
  1168  	// each copy of the cell is counted separately.
  1169  	CellsPerColumnLimitFilter int32 `protobuf:"varint,12,opt,name=cells_per_column_limit_filter,json=cellsPerColumnLimitFilter,proto3,oneof"`
  1170  }
  1171  
  1172  type RowFilter_StripValueTransformer struct {
  1173  	// Replaces each cell's value with the empty string.
  1174  	StripValueTransformer bool `protobuf:"varint,13,opt,name=strip_value_transformer,json=stripValueTransformer,proto3,oneof"`
  1175  }
  1176  
  1177  type RowFilter_ApplyLabelTransformer struct {
  1178  	// Applies the given label to all cells in the output row. This allows
  1179  	// the client to determine which results were produced from which part of
  1180  	// the filter.
  1181  	//
  1182  	// Values must be at most 15 characters in length, and match the RE2
  1183  	// pattern [a-z0-9\\-]+
  1184  	//
  1185  	// Due to a technical limitation, it is not currently possible to apply
  1186  	// multiple labels to a cell. As a result, a Chain may have no more than
  1187  	// one sub-filter which contains a apply_label_transformer. It is okay for
  1188  	// an Interleave to contain multiple apply_label_transformers, as they will
  1189  	// be applied to separate copies of the input. This may be relaxed in the
  1190  	// future.
  1191  	ApplyLabelTransformer string `protobuf:"bytes,19,opt,name=apply_label_transformer,json=applyLabelTransformer,proto3,oneof"`
  1192  }
  1193  
  1194  func (*RowFilter_Chain_) isRowFilter_Filter() {}
  1195  
  1196  func (*RowFilter_Interleave_) isRowFilter_Filter() {}
  1197  
  1198  func (*RowFilter_Condition_) isRowFilter_Filter() {}
  1199  
  1200  func (*RowFilter_Sink) isRowFilter_Filter() {}
  1201  
  1202  func (*RowFilter_PassAllFilter) isRowFilter_Filter() {}
  1203  
  1204  func (*RowFilter_BlockAllFilter) isRowFilter_Filter() {}
  1205  
  1206  func (*RowFilter_RowKeyRegexFilter) isRowFilter_Filter() {}
  1207  
  1208  func (*RowFilter_RowSampleFilter) isRowFilter_Filter() {}
  1209  
  1210  func (*RowFilter_FamilyNameRegexFilter) isRowFilter_Filter() {}
  1211  
  1212  func (*RowFilter_ColumnQualifierRegexFilter) isRowFilter_Filter() {}
  1213  
  1214  func (*RowFilter_ColumnRangeFilter) isRowFilter_Filter() {}
  1215  
  1216  func (*RowFilter_TimestampRangeFilter) isRowFilter_Filter() {}
  1217  
  1218  func (*RowFilter_ValueRegexFilter) isRowFilter_Filter() {}
  1219  
  1220  func (*RowFilter_ValueRangeFilter) isRowFilter_Filter() {}
  1221  
  1222  func (*RowFilter_CellsPerRowOffsetFilter) isRowFilter_Filter() {}
  1223  
  1224  func (*RowFilter_CellsPerRowLimitFilter) isRowFilter_Filter() {}
  1225  
  1226  func (*RowFilter_CellsPerColumnLimitFilter) isRowFilter_Filter() {}
  1227  
  1228  func (*RowFilter_StripValueTransformer) isRowFilter_Filter() {}
  1229  
  1230  func (*RowFilter_ApplyLabelTransformer) isRowFilter_Filter() {}
  1231  
  1232  // Specifies a particular change to be made to the contents of a row.
  1233  type Mutation struct {
  1234  	state         protoimpl.MessageState
  1235  	sizeCache     protoimpl.SizeCache
  1236  	unknownFields protoimpl.UnknownFields
  1237  
  1238  	// Which of the possible Mutation types to apply.
  1239  	//
  1240  	// Types that are assignable to Mutation:
  1241  	//	*Mutation_SetCell_
  1242  	//	*Mutation_DeleteFromColumn_
  1243  	//	*Mutation_DeleteFromFamily_
  1244  	//	*Mutation_DeleteFromRow_
  1245  	Mutation isMutation_Mutation `protobuf_oneof:"mutation"`
  1246  }
  1247  
  1248  func (x *Mutation) Reset() {
  1249  	*x = Mutation{}
  1250  	if protoimpl.UnsafeEnabled {
  1251  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[10]
  1252  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1253  		ms.StoreMessageInfo(mi)
  1254  	}
  1255  }
  1256  
  1257  func (x *Mutation) String() string {
  1258  	return protoimpl.X.MessageStringOf(x)
  1259  }
  1260  
  1261  func (*Mutation) ProtoMessage() {}
  1262  
  1263  func (x *Mutation) ProtoReflect() protoreflect.Message {
  1264  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[10]
  1265  	if protoimpl.UnsafeEnabled && x != nil {
  1266  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1267  		if ms.LoadMessageInfo() == nil {
  1268  			ms.StoreMessageInfo(mi)
  1269  		}
  1270  		return ms
  1271  	}
  1272  	return mi.MessageOf(x)
  1273  }
  1274  
  1275  // Deprecated: Use Mutation.ProtoReflect.Descriptor instead.
  1276  func (*Mutation) Descriptor() ([]byte, []int) {
  1277  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{10}
  1278  }
  1279  
  1280  func (m *Mutation) GetMutation() isMutation_Mutation {
  1281  	if m != nil {
  1282  		return m.Mutation
  1283  	}
  1284  	return nil
  1285  }
  1286  
  1287  func (x *Mutation) GetSetCell() *Mutation_SetCell {
  1288  	if x, ok := x.GetMutation().(*Mutation_SetCell_); ok {
  1289  		return x.SetCell
  1290  	}
  1291  	return nil
  1292  }
  1293  
  1294  func (x *Mutation) GetDeleteFromColumn() *Mutation_DeleteFromColumn {
  1295  	if x, ok := x.GetMutation().(*Mutation_DeleteFromColumn_); ok {
  1296  		return x.DeleteFromColumn
  1297  	}
  1298  	return nil
  1299  }
  1300  
  1301  func (x *Mutation) GetDeleteFromFamily() *Mutation_DeleteFromFamily {
  1302  	if x, ok := x.GetMutation().(*Mutation_DeleteFromFamily_); ok {
  1303  		return x.DeleteFromFamily
  1304  	}
  1305  	return nil
  1306  }
  1307  
  1308  func (x *Mutation) GetDeleteFromRow() *Mutation_DeleteFromRow {
  1309  	if x, ok := x.GetMutation().(*Mutation_DeleteFromRow_); ok {
  1310  		return x.DeleteFromRow
  1311  	}
  1312  	return nil
  1313  }
  1314  
  1315  type isMutation_Mutation interface {
  1316  	isMutation_Mutation()
  1317  }
  1318  
  1319  type Mutation_SetCell_ struct {
  1320  	// Set a cell's value.
  1321  	SetCell *Mutation_SetCell `protobuf:"bytes,1,opt,name=set_cell,json=setCell,proto3,oneof"`
  1322  }
  1323  
  1324  type Mutation_DeleteFromColumn_ struct {
  1325  	// Deletes cells from a column.
  1326  	DeleteFromColumn *Mutation_DeleteFromColumn `protobuf:"bytes,2,opt,name=delete_from_column,json=deleteFromColumn,proto3,oneof"`
  1327  }
  1328  
  1329  type Mutation_DeleteFromFamily_ struct {
  1330  	// Deletes cells from a column family.
  1331  	DeleteFromFamily *Mutation_DeleteFromFamily `protobuf:"bytes,3,opt,name=delete_from_family,json=deleteFromFamily,proto3,oneof"`
  1332  }
  1333  
  1334  type Mutation_DeleteFromRow_ struct {
  1335  	// Deletes cells from the entire row.
  1336  	DeleteFromRow *Mutation_DeleteFromRow `protobuf:"bytes,4,opt,name=delete_from_row,json=deleteFromRow,proto3,oneof"`
  1337  }
  1338  
  1339  func (*Mutation_SetCell_) isMutation_Mutation() {}
  1340  
  1341  func (*Mutation_DeleteFromColumn_) isMutation_Mutation() {}
  1342  
  1343  func (*Mutation_DeleteFromFamily_) isMutation_Mutation() {}
  1344  
  1345  func (*Mutation_DeleteFromRow_) isMutation_Mutation() {}
  1346  
  1347  // Specifies an atomic read/modify/write operation on the latest value of the
  1348  // specified column.
  1349  type ReadModifyWriteRule struct {
  1350  	state         protoimpl.MessageState
  1351  	sizeCache     protoimpl.SizeCache
  1352  	unknownFields protoimpl.UnknownFields
  1353  
  1354  	// The name of the family to which the read/modify/write should be applied.
  1355  	// Must match [-_.a-zA-Z0-9]+
  1356  	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
  1357  	// The qualifier of the column to which the read/modify/write should be
  1358  	// applied.
  1359  	// Can be any byte string, including the empty string.
  1360  	ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
  1361  	// The rule used to determine the column's new latest value from its current
  1362  	// latest value.
  1363  	//
  1364  	// Types that are assignable to Rule:
  1365  	//	*ReadModifyWriteRule_AppendValue
  1366  	//	*ReadModifyWriteRule_IncrementAmount
  1367  	Rule isReadModifyWriteRule_Rule `protobuf_oneof:"rule"`
  1368  }
  1369  
  1370  func (x *ReadModifyWriteRule) Reset() {
  1371  	*x = ReadModifyWriteRule{}
  1372  	if protoimpl.UnsafeEnabled {
  1373  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[11]
  1374  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1375  		ms.StoreMessageInfo(mi)
  1376  	}
  1377  }
  1378  
  1379  func (x *ReadModifyWriteRule) String() string {
  1380  	return protoimpl.X.MessageStringOf(x)
  1381  }
  1382  
  1383  func (*ReadModifyWriteRule) ProtoMessage() {}
  1384  
  1385  func (x *ReadModifyWriteRule) ProtoReflect() protoreflect.Message {
  1386  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[11]
  1387  	if protoimpl.UnsafeEnabled && x != nil {
  1388  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1389  		if ms.LoadMessageInfo() == nil {
  1390  			ms.StoreMessageInfo(mi)
  1391  		}
  1392  		return ms
  1393  	}
  1394  	return mi.MessageOf(x)
  1395  }
  1396  
  1397  // Deprecated: Use ReadModifyWriteRule.ProtoReflect.Descriptor instead.
  1398  func (*ReadModifyWriteRule) Descriptor() ([]byte, []int) {
  1399  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{11}
  1400  }
  1401  
  1402  func (x *ReadModifyWriteRule) GetFamilyName() string {
  1403  	if x != nil {
  1404  		return x.FamilyName
  1405  	}
  1406  	return ""
  1407  }
  1408  
  1409  func (x *ReadModifyWriteRule) GetColumnQualifier() []byte {
  1410  	if x != nil {
  1411  		return x.ColumnQualifier
  1412  	}
  1413  	return nil
  1414  }
  1415  
  1416  func (m *ReadModifyWriteRule) GetRule() isReadModifyWriteRule_Rule {
  1417  	if m != nil {
  1418  		return m.Rule
  1419  	}
  1420  	return nil
  1421  }
  1422  
  1423  func (x *ReadModifyWriteRule) GetAppendValue() []byte {
  1424  	if x, ok := x.GetRule().(*ReadModifyWriteRule_AppendValue); ok {
  1425  		return x.AppendValue
  1426  	}
  1427  	return nil
  1428  }
  1429  
  1430  func (x *ReadModifyWriteRule) GetIncrementAmount() int64 {
  1431  	if x, ok := x.GetRule().(*ReadModifyWriteRule_IncrementAmount); ok {
  1432  		return x.IncrementAmount
  1433  	}
  1434  	return 0
  1435  }
  1436  
  1437  type isReadModifyWriteRule_Rule interface {
  1438  	isReadModifyWriteRule_Rule()
  1439  }
  1440  
  1441  type ReadModifyWriteRule_AppendValue struct {
  1442  	// Rule specifying that "append_value" be appended to the existing value.
  1443  	// If the targeted cell is unset, it will be treated as containing the
  1444  	// empty string.
  1445  	AppendValue []byte `protobuf:"bytes,3,opt,name=append_value,json=appendValue,proto3,oneof"`
  1446  }
  1447  
  1448  type ReadModifyWriteRule_IncrementAmount struct {
  1449  	// Rule specifying that "increment_amount" be added to the existing value.
  1450  	// If the targeted cell is unset, it will be treated as containing a zero.
  1451  	// Otherwise, the targeted cell must contain an 8-byte value (interpreted
  1452  	// as a 64-bit big-endian signed integer), or the entire request will fail.
  1453  	IncrementAmount int64 `protobuf:"varint,4,opt,name=increment_amount,json=incrementAmount,proto3,oneof"`
  1454  }
  1455  
  1456  func (*ReadModifyWriteRule_AppendValue) isReadModifyWriteRule_Rule() {}
  1457  
  1458  func (*ReadModifyWriteRule_IncrementAmount) isReadModifyWriteRule_Rule() {}
  1459  
  1460  // A RowFilter which sends rows through several RowFilters in sequence.
  1461  type RowFilter_Chain struct {
  1462  	state         protoimpl.MessageState
  1463  	sizeCache     protoimpl.SizeCache
  1464  	unknownFields protoimpl.UnknownFields
  1465  
  1466  	// The elements of "filters" are chained together to process the input row:
  1467  	// in row -> f(0) -> intermediate row -> f(1) -> ... -> f(N) -> out row
  1468  	// The full chain is executed atomically.
  1469  	Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
  1470  }
  1471  
  1472  func (x *RowFilter_Chain) Reset() {
  1473  	*x = RowFilter_Chain{}
  1474  	if protoimpl.UnsafeEnabled {
  1475  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[12]
  1476  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1477  		ms.StoreMessageInfo(mi)
  1478  	}
  1479  }
  1480  
  1481  func (x *RowFilter_Chain) String() string {
  1482  	return protoimpl.X.MessageStringOf(x)
  1483  }
  1484  
  1485  func (*RowFilter_Chain) ProtoMessage() {}
  1486  
  1487  func (x *RowFilter_Chain) ProtoReflect() protoreflect.Message {
  1488  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[12]
  1489  	if protoimpl.UnsafeEnabled && x != nil {
  1490  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1491  		if ms.LoadMessageInfo() == nil {
  1492  			ms.StoreMessageInfo(mi)
  1493  		}
  1494  		return ms
  1495  	}
  1496  	return mi.MessageOf(x)
  1497  }
  1498  
  1499  // Deprecated: Use RowFilter_Chain.ProtoReflect.Descriptor instead.
  1500  func (*RowFilter_Chain) Descriptor() ([]byte, []int) {
  1501  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{9, 0}
  1502  }
  1503  
  1504  func (x *RowFilter_Chain) GetFilters() []*RowFilter {
  1505  	if x != nil {
  1506  		return x.Filters
  1507  	}
  1508  	return nil
  1509  }
  1510  
  1511  // A RowFilter which sends each row to each of several component
  1512  // RowFilters and interleaves the results.
  1513  type RowFilter_Interleave struct {
  1514  	state         protoimpl.MessageState
  1515  	sizeCache     protoimpl.SizeCache
  1516  	unknownFields protoimpl.UnknownFields
  1517  
  1518  	// The elements of "filters" all process a copy of the input row, and the
  1519  	// results are pooled, sorted, and combined into a single output row.
  1520  	// If multiple cells are produced with the same column and timestamp,
  1521  	// they will all appear in the output row in an unspecified mutual order.
  1522  	// Consider the following example, with three filters:
  1523  	//
  1524  	//                              input row
  1525  	//                                  |
  1526  	//        -----------------------------------------------------
  1527  	//        |                         |                         |
  1528  	//       f(0)                      f(1)                      f(2)
  1529  	//        |                         |                         |
  1530  	// 1: foo,bar,10,x             foo,bar,10,z              far,bar,7,a
  1531  	// 2: foo,blah,11,z            far,blah,5,x              far,blah,5,x
  1532  	//        |                         |                         |
  1533  	//        -----------------------------------------------------
  1534  	//                                  |
  1535  	// 1:                        foo,bar,10,z     // could have switched with #2
  1536  	// 2:                        foo,bar,10,x     // could have switched with #1
  1537  	// 3:                        foo,blah,11,z
  1538  	// 4:                        far,bar,7,a
  1539  	// 5:                        far,blah,5,x     // identical to #6
  1540  	// 6:                        far,blah,5,x     // identical to #5
  1541  	// All interleaved filters are executed atomically.
  1542  	Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
  1543  }
  1544  
  1545  func (x *RowFilter_Interleave) Reset() {
  1546  	*x = RowFilter_Interleave{}
  1547  	if protoimpl.UnsafeEnabled {
  1548  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[13]
  1549  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1550  		ms.StoreMessageInfo(mi)
  1551  	}
  1552  }
  1553  
  1554  func (x *RowFilter_Interleave) String() string {
  1555  	return protoimpl.X.MessageStringOf(x)
  1556  }
  1557  
  1558  func (*RowFilter_Interleave) ProtoMessage() {}
  1559  
  1560  func (x *RowFilter_Interleave) ProtoReflect() protoreflect.Message {
  1561  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[13]
  1562  	if protoimpl.UnsafeEnabled && x != nil {
  1563  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1564  		if ms.LoadMessageInfo() == nil {
  1565  			ms.StoreMessageInfo(mi)
  1566  		}
  1567  		return ms
  1568  	}
  1569  	return mi.MessageOf(x)
  1570  }
  1571  
  1572  // Deprecated: Use RowFilter_Interleave.ProtoReflect.Descriptor instead.
  1573  func (*RowFilter_Interleave) Descriptor() ([]byte, []int) {
  1574  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{9, 1}
  1575  }
  1576  
  1577  func (x *RowFilter_Interleave) GetFilters() []*RowFilter {
  1578  	if x != nil {
  1579  		return x.Filters
  1580  	}
  1581  	return nil
  1582  }
  1583  
  1584  // A RowFilter which evaluates one of two possible RowFilters, depending on
  1585  // whether or not a predicate RowFilter outputs any cells from the input row.
  1586  //
  1587  // IMPORTANT NOTE: The predicate filter does not execute atomically with the
  1588  // true and false filters, which may lead to inconsistent or unexpected
  1589  // results. Additionally, Condition filters have poor performance, especially
  1590  // when filters are set for the false condition.
  1591  type RowFilter_Condition struct {
  1592  	state         protoimpl.MessageState
  1593  	sizeCache     protoimpl.SizeCache
  1594  	unknownFields protoimpl.UnknownFields
  1595  
  1596  	// If "predicate_filter" outputs any cells, then "true_filter" will be
  1597  	// evaluated on the input row. Otherwise, "false_filter" will be evaluated.
  1598  	PredicateFilter *RowFilter `protobuf:"bytes,1,opt,name=predicate_filter,json=predicateFilter,proto3" json:"predicate_filter,omitempty"`
  1599  	// The filter to apply to the input row if "predicate_filter" returns any
  1600  	// results. If not provided, no results will be returned in the true case.
  1601  	TrueFilter *RowFilter `protobuf:"bytes,2,opt,name=true_filter,json=trueFilter,proto3" json:"true_filter,omitempty"`
  1602  	// The filter to apply to the input row if "predicate_filter" does not
  1603  	// return any results. If not provided, no results will be returned in the
  1604  	// false case.
  1605  	FalseFilter *RowFilter `protobuf:"bytes,3,opt,name=false_filter,json=falseFilter,proto3" json:"false_filter,omitempty"`
  1606  }
  1607  
  1608  func (x *RowFilter_Condition) Reset() {
  1609  	*x = RowFilter_Condition{}
  1610  	if protoimpl.UnsafeEnabled {
  1611  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[14]
  1612  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1613  		ms.StoreMessageInfo(mi)
  1614  	}
  1615  }
  1616  
  1617  func (x *RowFilter_Condition) String() string {
  1618  	return protoimpl.X.MessageStringOf(x)
  1619  }
  1620  
  1621  func (*RowFilter_Condition) ProtoMessage() {}
  1622  
  1623  func (x *RowFilter_Condition) ProtoReflect() protoreflect.Message {
  1624  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[14]
  1625  	if protoimpl.UnsafeEnabled && x != nil {
  1626  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1627  		if ms.LoadMessageInfo() == nil {
  1628  			ms.StoreMessageInfo(mi)
  1629  		}
  1630  		return ms
  1631  	}
  1632  	return mi.MessageOf(x)
  1633  }
  1634  
  1635  // Deprecated: Use RowFilter_Condition.ProtoReflect.Descriptor instead.
  1636  func (*RowFilter_Condition) Descriptor() ([]byte, []int) {
  1637  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{9, 2}
  1638  }
  1639  
  1640  func (x *RowFilter_Condition) GetPredicateFilter() *RowFilter {
  1641  	if x != nil {
  1642  		return x.PredicateFilter
  1643  	}
  1644  	return nil
  1645  }
  1646  
  1647  func (x *RowFilter_Condition) GetTrueFilter() *RowFilter {
  1648  	if x != nil {
  1649  		return x.TrueFilter
  1650  	}
  1651  	return nil
  1652  }
  1653  
  1654  func (x *RowFilter_Condition) GetFalseFilter() *RowFilter {
  1655  	if x != nil {
  1656  		return x.FalseFilter
  1657  	}
  1658  	return nil
  1659  }
  1660  
  1661  // A Mutation which sets the value of the specified cell.
  1662  type Mutation_SetCell struct {
  1663  	state         protoimpl.MessageState
  1664  	sizeCache     protoimpl.SizeCache
  1665  	unknownFields protoimpl.UnknownFields
  1666  
  1667  	// The name of the family into which new data should be written.
  1668  	// Must match [-_.a-zA-Z0-9]+
  1669  	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
  1670  	// The qualifier of the column into which new data should be written.
  1671  	// Can be any byte string, including the empty string.
  1672  	ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
  1673  	// The timestamp of the cell into which new data should be written.
  1674  	// Use -1 for current Bigtable server time.
  1675  	// Otherwise, the client should set this value itself, noting that the
  1676  	// default value is a timestamp of zero if the field is left unspecified.
  1677  	// Values must match the "granularity" of the table (e.g. micros, millis).
  1678  	TimestampMicros int64 `protobuf:"varint,3,opt,name=timestamp_micros,json=timestampMicros,proto3" json:"timestamp_micros,omitempty"`
  1679  	// The value to be written into the specified cell.
  1680  	Value []byte `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
  1681  }
  1682  
  1683  func (x *Mutation_SetCell) Reset() {
  1684  	*x = Mutation_SetCell{}
  1685  	if protoimpl.UnsafeEnabled {
  1686  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[15]
  1687  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1688  		ms.StoreMessageInfo(mi)
  1689  	}
  1690  }
  1691  
  1692  func (x *Mutation_SetCell) String() string {
  1693  	return protoimpl.X.MessageStringOf(x)
  1694  }
  1695  
  1696  func (*Mutation_SetCell) ProtoMessage() {}
  1697  
  1698  func (x *Mutation_SetCell) ProtoReflect() protoreflect.Message {
  1699  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[15]
  1700  	if protoimpl.UnsafeEnabled && x != nil {
  1701  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1702  		if ms.LoadMessageInfo() == nil {
  1703  			ms.StoreMessageInfo(mi)
  1704  		}
  1705  		return ms
  1706  	}
  1707  	return mi.MessageOf(x)
  1708  }
  1709  
  1710  // Deprecated: Use Mutation_SetCell.ProtoReflect.Descriptor instead.
  1711  func (*Mutation_SetCell) Descriptor() ([]byte, []int) {
  1712  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{10, 0}
  1713  }
  1714  
  1715  func (x *Mutation_SetCell) GetFamilyName() string {
  1716  	if x != nil {
  1717  		return x.FamilyName
  1718  	}
  1719  	return ""
  1720  }
  1721  
  1722  func (x *Mutation_SetCell) GetColumnQualifier() []byte {
  1723  	if x != nil {
  1724  		return x.ColumnQualifier
  1725  	}
  1726  	return nil
  1727  }
  1728  
  1729  func (x *Mutation_SetCell) GetTimestampMicros() int64 {
  1730  	if x != nil {
  1731  		return x.TimestampMicros
  1732  	}
  1733  	return 0
  1734  }
  1735  
  1736  func (x *Mutation_SetCell) GetValue() []byte {
  1737  	if x != nil {
  1738  		return x.Value
  1739  	}
  1740  	return nil
  1741  }
  1742  
  1743  // A Mutation which deletes cells from the specified column, optionally
  1744  // restricting the deletions to a given timestamp range.
  1745  type Mutation_DeleteFromColumn struct {
  1746  	state         protoimpl.MessageState
  1747  	sizeCache     protoimpl.SizeCache
  1748  	unknownFields protoimpl.UnknownFields
  1749  
  1750  	// The name of the family from which cells should be deleted.
  1751  	// Must match [-_.a-zA-Z0-9]+
  1752  	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
  1753  	// The qualifier of the column from which cells should be deleted.
  1754  	// Can be any byte string, including the empty string.
  1755  	ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
  1756  	// The range of timestamps within which cells should be deleted.
  1757  	TimeRange *TimestampRange `protobuf:"bytes,3,opt,name=time_range,json=timeRange,proto3" json:"time_range,omitempty"`
  1758  }
  1759  
  1760  func (x *Mutation_DeleteFromColumn) Reset() {
  1761  	*x = Mutation_DeleteFromColumn{}
  1762  	if protoimpl.UnsafeEnabled {
  1763  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[16]
  1764  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1765  		ms.StoreMessageInfo(mi)
  1766  	}
  1767  }
  1768  
  1769  func (x *Mutation_DeleteFromColumn) String() string {
  1770  	return protoimpl.X.MessageStringOf(x)
  1771  }
  1772  
  1773  func (*Mutation_DeleteFromColumn) ProtoMessage() {}
  1774  
  1775  func (x *Mutation_DeleteFromColumn) ProtoReflect() protoreflect.Message {
  1776  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[16]
  1777  	if protoimpl.UnsafeEnabled && x != nil {
  1778  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1779  		if ms.LoadMessageInfo() == nil {
  1780  			ms.StoreMessageInfo(mi)
  1781  		}
  1782  		return ms
  1783  	}
  1784  	return mi.MessageOf(x)
  1785  }
  1786  
  1787  // Deprecated: Use Mutation_DeleteFromColumn.ProtoReflect.Descriptor instead.
  1788  func (*Mutation_DeleteFromColumn) Descriptor() ([]byte, []int) {
  1789  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{10, 1}
  1790  }
  1791  
  1792  func (x *Mutation_DeleteFromColumn) GetFamilyName() string {
  1793  	if x != nil {
  1794  		return x.FamilyName
  1795  	}
  1796  	return ""
  1797  }
  1798  
  1799  func (x *Mutation_DeleteFromColumn) GetColumnQualifier() []byte {
  1800  	if x != nil {
  1801  		return x.ColumnQualifier
  1802  	}
  1803  	return nil
  1804  }
  1805  
  1806  func (x *Mutation_DeleteFromColumn) GetTimeRange() *TimestampRange {
  1807  	if x != nil {
  1808  		return x.TimeRange
  1809  	}
  1810  	return nil
  1811  }
  1812  
  1813  // A Mutation which deletes all cells from the specified column family.
  1814  type Mutation_DeleteFromFamily struct {
  1815  	state         protoimpl.MessageState
  1816  	sizeCache     protoimpl.SizeCache
  1817  	unknownFields protoimpl.UnknownFields
  1818  
  1819  	// The name of the family from which cells should be deleted.
  1820  	// Must match [-_.a-zA-Z0-9]+
  1821  	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
  1822  }
  1823  
  1824  func (x *Mutation_DeleteFromFamily) Reset() {
  1825  	*x = Mutation_DeleteFromFamily{}
  1826  	if protoimpl.UnsafeEnabled {
  1827  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[17]
  1828  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1829  		ms.StoreMessageInfo(mi)
  1830  	}
  1831  }
  1832  
  1833  func (x *Mutation_DeleteFromFamily) String() string {
  1834  	return protoimpl.X.MessageStringOf(x)
  1835  }
  1836  
  1837  func (*Mutation_DeleteFromFamily) ProtoMessage() {}
  1838  
  1839  func (x *Mutation_DeleteFromFamily) ProtoReflect() protoreflect.Message {
  1840  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[17]
  1841  	if protoimpl.UnsafeEnabled && x != nil {
  1842  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1843  		if ms.LoadMessageInfo() == nil {
  1844  			ms.StoreMessageInfo(mi)
  1845  		}
  1846  		return ms
  1847  	}
  1848  	return mi.MessageOf(x)
  1849  }
  1850  
  1851  // Deprecated: Use Mutation_DeleteFromFamily.ProtoReflect.Descriptor instead.
  1852  func (*Mutation_DeleteFromFamily) Descriptor() ([]byte, []int) {
  1853  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{10, 2}
  1854  }
  1855  
  1856  func (x *Mutation_DeleteFromFamily) GetFamilyName() string {
  1857  	if x != nil {
  1858  		return x.FamilyName
  1859  	}
  1860  	return ""
  1861  }
  1862  
  1863  // A Mutation which deletes all cells from the containing row.
  1864  type Mutation_DeleteFromRow struct {
  1865  	state         protoimpl.MessageState
  1866  	sizeCache     protoimpl.SizeCache
  1867  	unknownFields protoimpl.UnknownFields
  1868  }
  1869  
  1870  func (x *Mutation_DeleteFromRow) Reset() {
  1871  	*x = Mutation_DeleteFromRow{}
  1872  	if protoimpl.UnsafeEnabled {
  1873  		mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[18]
  1874  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1875  		ms.StoreMessageInfo(mi)
  1876  	}
  1877  }
  1878  
  1879  func (x *Mutation_DeleteFromRow) String() string {
  1880  	return protoimpl.X.MessageStringOf(x)
  1881  }
  1882  
  1883  func (*Mutation_DeleteFromRow) ProtoMessage() {}
  1884  
  1885  func (x *Mutation_DeleteFromRow) ProtoReflect() protoreflect.Message {
  1886  	mi := &file_google_bigtable_v1_bigtable_data_proto_msgTypes[18]
  1887  	if protoimpl.UnsafeEnabled && x != nil {
  1888  		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
  1889  		if ms.LoadMessageInfo() == nil {
  1890  			ms.StoreMessageInfo(mi)
  1891  		}
  1892  		return ms
  1893  	}
  1894  	return mi.MessageOf(x)
  1895  }
  1896  
  1897  // Deprecated: Use Mutation_DeleteFromRow.ProtoReflect.Descriptor instead.
  1898  func (*Mutation_DeleteFromRow) Descriptor() ([]byte, []int) {
  1899  	return file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP(), []int{10, 3}
  1900  }
  1901  
  1902  var File_google_bigtable_v1_bigtable_data_proto protoreflect.FileDescriptor
  1903  
  1904  var file_google_bigtable_v1_bigtable_data_proto_rawDesc = []byte{
  1905  	0x0a, 0x26, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c,
  1906  	0x65, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x64, 0x61,
  1907  	0x74, 0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
  1908  	0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x22, 0x4f, 0x0a, 0x03,
  1909  	0x52, 0x6f, 0x77, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c,
  1910  	0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x36, 0x0a, 0x08, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x69, 0x65,
  1911  	0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
  1912  	0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x61, 0x6d,
  1913  	0x69, 0x6c, 0x79, 0x52, 0x08, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x69, 0x65, 0x73, 0x22, 0x52, 0x0a,
  1914  	0x06, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18,
  1915  	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x34, 0x0a, 0x07, 0x63,
  1916  	0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67,
  1917  	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76,
  1918  	0x31, 0x2e, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e,
  1919  	0x73, 0x22, 0x56, 0x0a, 0x06, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x71,
  1920  	0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09,
  1921  	0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x2e, 0x0a, 0x05, 0x63, 0x65, 0x6c,
  1922  	0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
  1923  	0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x65,
  1924  	0x6c, 0x6c, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x22, 0x5f, 0x0a, 0x04, 0x43, 0x65, 0x6c,
  1925  	0x6c, 0x12, 0x29, 0x0a, 0x10, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6d,
  1926  	0x69, 0x63, 0x72, 0x6f, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x74, 0x69, 0x6d,
  1927  	0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x12, 0x14, 0x0a, 0x05,
  1928  	0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c,
  1929  	0x75, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03,
  1930  	0x28, 0x09, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x22, 0x40, 0x0a, 0x08, 0x52, 0x6f,
  1931  	0x77, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f,
  1932  	0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x73, 0x74, 0x61, 0x72, 0x74,
  1933  	0x4b, 0x65, 0x79, 0x12, 0x17, 0x0a, 0x07, 0x65, 0x6e, 0x64, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03,
  1934  	0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x65, 0x6e, 0x64, 0x4b, 0x65, 0x79, 0x22, 0x60, 0x0a, 0x06,
  1935  	0x52, 0x6f, 0x77, 0x53, 0x65, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f, 0x77, 0x5f, 0x6b, 0x65,
  1936  	0x79, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x07, 0x72, 0x6f, 0x77, 0x4b, 0x65, 0x79,
  1937  	0x73, 0x12, 0x3b, 0x0a, 0x0a, 0x72, 0x6f, 0x77, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x18,
  1938  	0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62,
  1939  	0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, 0x77, 0x52, 0x61,
  1940  	0x6e, 0x67, 0x65, 0x52, 0x09, 0x72, 0x6f, 0x77, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x22, 0xc2,
  1941  	0x02, 0x0a, 0x0b, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1f,
  1942  	0x0a, 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20,
  1943  	0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12,
  1944  	0x3c, 0x0a, 0x19, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69,
  1945  	0x65, 0x72, 0x5f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x18, 0x02, 0x20, 0x01,
  1946  	0x28, 0x0c, 0x48, 0x00, 0x52, 0x17, 0x73, 0x74, 0x61, 0x72, 0x74, 0x51, 0x75, 0x61, 0x6c, 0x69,
  1947  	0x66, 0x69, 0x65, 0x72, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x12, 0x3c, 0x0a,
  1948  	0x19, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72,
  1949  	0x5f, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c,
  1950  	0x48, 0x00, 0x52, 0x17, 0x73, 0x74, 0x61, 0x72, 0x74, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69,
  1951  	0x65, 0x72, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x12, 0x38, 0x0a, 0x17, 0x65,
  1952  	0x6e, 0x64, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x63,
  1953  	0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x15,
  1954  	0x65, 0x6e, 0x64, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x49, 0x6e, 0x63, 0x6c,
  1955  	0x75, 0x73, 0x69, 0x76, 0x65, 0x12, 0x38, 0x0a, 0x17, 0x65, 0x6e, 0x64, 0x5f, 0x71, 0x75, 0x61,
  1956  	0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65,
  1957  	0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x15, 0x65, 0x6e, 0x64, 0x51, 0x75, 0x61,
  1958  	0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x42,
  1959  	0x11, 0x0a, 0x0f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69,
  1960  	0x65, 0x72, 0x42, 0x0f, 0x0a, 0x0d, 0x65, 0x6e, 0x64, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66,
  1961  	0x69, 0x65, 0x72, 0x22, 0x78, 0x0a, 0x0e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
  1962  	0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x34, 0x0a, 0x16, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74,
  1963  	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x18,
  1964  	0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65,
  1965  	0x73, 0x74, 0x61, 0x6d, 0x70, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x65,
  1966  	0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6d, 0x69, 0x63,
  1967  	0x72, 0x6f, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x65, 0x6e, 0x64, 0x54, 0x69,
  1968  	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x22, 0xf8, 0x01,
  1969  	0x0a, 0x0a, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x34, 0x0a, 0x15,
  1970  	0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x69, 0x6e, 0x63, 0x6c,
  1971  	0x75, 0x73, 0x69, 0x76, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x13, 0x73,
  1972  	0x74, 0x61, 0x72, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69,
  1973  	0x76, 0x65, 0x12, 0x34, 0x0a, 0x15, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75,
  1974  	0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
  1975  	0x0c, 0x48, 0x00, 0x52, 0x13, 0x73, 0x74, 0x61, 0x72, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x45,
  1976  	0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x12, 0x30, 0x0a, 0x13, 0x65, 0x6e, 0x64, 0x5f,
  1977  	0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x18,
  1978  	0x03, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x11, 0x65, 0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75,
  1979  	0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x12, 0x30, 0x0a, 0x13, 0x65, 0x6e,
  1980  	0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76,
  1981  	0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x11, 0x65, 0x6e, 0x64, 0x56, 0x61,
  1982  	0x6c, 0x75, 0x65, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x42, 0x0d, 0x0a, 0x0b,
  1983  	0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x65,
  1984  	0x6e, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xfc, 0x0b, 0x0a, 0x09, 0x52, 0x6f, 0x77,
  1985  	0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x3b, 0x0a, 0x05, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18,
  1986  	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62,
  1987  	0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69,
  1988  	0x6c, 0x74, 0x65, 0x72, 0x2e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x48, 0x00, 0x52, 0x05, 0x63, 0x68,
  1989  	0x61, 0x69, 0x6e, 0x12, 0x4a, 0x0a, 0x0a, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6c, 0x65, 0x61, 0x76,
  1990  	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
  1991  	0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, 0x77,
  1992  	0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6c, 0x65, 0x61, 0x76,
  1993  	0x65, 0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x12,
  1994  	0x47, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01,
  1995  	0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74,
  1996  	0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65,
  1997  	0x72, 0x2e, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x09, 0x63,
  1998  	0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x04, 0x73, 0x69, 0x6e, 0x6b,
  1999  	0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x04, 0x73, 0x69, 0x6e, 0x6b, 0x12, 0x28,
  2000  	0x0a, 0x0f, 0x70, 0x61, 0x73, 0x73, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65,
  2001  	0x72, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0d, 0x70, 0x61, 0x73, 0x73, 0x41,
  2002  	0x6c, 0x6c, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x10, 0x62, 0x6c, 0x6f, 0x63,
  2003  	0x6b, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x12, 0x20, 0x01,
  2004  	0x28, 0x08, 0x48, 0x00, 0x52, 0x0e, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x41, 0x6c, 0x6c, 0x46, 0x69,
  2005  	0x6c, 0x74, 0x65, 0x72, 0x12, 0x31, 0x0a, 0x14, 0x72, 0x6f, 0x77, 0x5f, 0x6b, 0x65, 0x79, 0x5f,
  2006  	0x72, 0x65, 0x67, 0x65, 0x78, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01,
  2007  	0x28, 0x0c, 0x48, 0x00, 0x52, 0x11, 0x72, 0x6f, 0x77, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x67, 0x65,
  2008  	0x78, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x2c, 0x0a, 0x11, 0x72, 0x6f, 0x77, 0x5f, 0x73,
  2009  	0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x0e, 0x20, 0x01,
  2010  	0x28, 0x01, 0x48, 0x00, 0x52, 0x0f, 0x72, 0x6f, 0x77, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x46,
  2011  	0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x39, 0x0a, 0x18, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f,
  2012  	0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65,
  2013  	0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x15, 0x66, 0x61, 0x6d, 0x69, 0x6c,
  2014  	0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x67, 0x65, 0x78, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72,
  2015  	0x12, 0x43, 0x0a, 0x1d, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69,
  2016  	0x66, 0x69, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65,
  2017  	0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x1a, 0x63, 0x6f, 0x6c, 0x75, 0x6d,
  2018  	0x6e, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x65, 0x67, 0x65, 0x78, 0x46,
  2019  	0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x51, 0x0a, 0x13, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f,
  2020  	0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x07, 0x20, 0x01,
  2021  	0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74,
  2022  	0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x61,
  2023  	0x6e, 0x67, 0x65, 0x48, 0x00, 0x52, 0x11, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x61, 0x6e,
  2024  	0x67, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x5a, 0x0a, 0x16, 0x74, 0x69, 0x6d, 0x65,
  2025  	0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74,
  2026  	0x65, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
  2027  	0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x69,
  2028  	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48, 0x00, 0x52, 0x14,
  2029  	0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x46, 0x69,
  2030  	0x6c, 0x74, 0x65, 0x72, 0x12, 0x2e, 0x0a, 0x12, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x72, 0x65,
  2031  	0x67, 0x65, 0x78, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c,
  2032  	0x48, 0x00, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x67, 0x65, 0x78, 0x46, 0x69,
  2033  	0x6c, 0x74, 0x65, 0x72, 0x12, 0x4e, 0x0a, 0x12, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x72, 0x61,
  2034  	0x6e, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b,
  2035  	0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62,
  2036  	0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65,
  2037  	0x48, 0x00, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x46, 0x69,
  2038  	0x6c, 0x74, 0x65, 0x72, 0x12, 0x3e, 0x0a, 0x1b, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x5f, 0x70, 0x65,
  2039  	0x72, 0x5f, 0x72, 0x6f, 0x77, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x5f, 0x66, 0x69, 0x6c,
  2040  	0x74, 0x65, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x17, 0x63, 0x65, 0x6c,
  2041  	0x6c, 0x73, 0x50, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x46, 0x69,
  2042  	0x6c, 0x74, 0x65, 0x72, 0x12, 0x3c, 0x0a, 0x1a, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x5f, 0x70, 0x65,
  2043  	0x72, 0x5f, 0x72, 0x6f, 0x77, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x74,
  2044  	0x65, 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x16, 0x63, 0x65, 0x6c, 0x6c,
  2045  	0x73, 0x50, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x46, 0x69, 0x6c, 0x74,
  2046  	0x65, 0x72, 0x12, 0x42, 0x0a, 0x1d, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x5f,
  2047  	0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x66, 0x69, 0x6c,
  2048  	0x74, 0x65, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x19, 0x63, 0x65, 0x6c,
  2049  	0x6c, 0x73, 0x50, 0x65, 0x72, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4c, 0x69, 0x6d, 0x69, 0x74,
  2050  	0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x38, 0x0a, 0x17, 0x73, 0x74, 0x72, 0x69, 0x70, 0x5f,
  2051  	0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x65,
  2052  	0x72, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x15, 0x73, 0x74, 0x72, 0x69, 0x70,
  2053  	0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x72,
  2054  	0x12, 0x38, 0x0a, 0x17, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x5f,
  2055  	0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x72, 0x18, 0x13, 0x20, 0x01, 0x28,
  2056  	0x09, 0x48, 0x00, 0x52, 0x15, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x54,
  2057  	0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x72, 0x1a, 0x40, 0x0a, 0x05, 0x43, 0x68,
  2058  	0x61, 0x69, 0x6e, 0x12, 0x37, 0x0a, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x18, 0x01,
  2059  	0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69,
  2060  	0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c,
  2061  	0x74, 0x65, 0x72, 0x52, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x1a, 0x45, 0x0a, 0x0a,
  2062  	0x49, 0x6e, 0x74, 0x65, 0x72, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x66, 0x69,
  2063  	0x6c, 0x74, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f,
  2064  	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31,
  2065  	0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x07, 0x66, 0x69, 0x6c, 0x74,
  2066  	0x65, 0x72, 0x73, 0x1a, 0xd7, 0x01, 0x0a, 0x09, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f,
  2067  	0x6e, 0x12, 0x48, 0x0a, 0x10, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x5f, 0x66,
  2068  	0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f,
  2069  	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31,
  2070  	0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x0f, 0x70, 0x72, 0x65, 0x64,
  2071  	0x69, 0x63, 0x61, 0x74, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x3e, 0x0a, 0x0b, 0x74,
  2072  	0x72, 0x75, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
  2073  	0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62,
  2074  	0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52,
  2075  	0x0a, 0x74, 0x72, 0x75, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x40, 0x0a, 0x0c, 0x66,
  2076  	0x61, 0x6c, 0x73, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28,
  2077  	0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61,
  2078  	0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72,
  2079  	0x52, 0x0b, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x42, 0x08, 0x0a,
  2080  	0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0xf0, 0x05, 0x0a, 0x08, 0x4d, 0x75, 0x74, 0x61,
  2081  	0x74, 0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x08, 0x73, 0x65, 0x74, 0x5f, 0x63, 0x65, 0x6c, 0x6c,
  2082  	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
  2083  	0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x75, 0x74, 0x61,
  2084  	0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x53, 0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x48, 0x00, 0x52, 0x07,
  2085  	0x73, 0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x5d, 0x0a, 0x12, 0x64, 0x65, 0x6c, 0x65, 0x74,
  2086  	0x65, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x18, 0x02, 0x20,
  2087  	0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67,
  2088  	0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f,
  2089  	0x6e, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x6f, 0x6c, 0x75,
  2090  	0x6d, 0x6e, 0x48, 0x00, 0x52, 0x10, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d,
  2091  	0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x5d, 0x0a, 0x12, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65,
  2092  	0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x18, 0x03, 0x20, 0x01,
  2093  	0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74,
  2094  	0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
  2095  	0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x46, 0x61, 0x6d, 0x69, 0x6c,
  2096  	0x79, 0x48, 0x00, 0x52, 0x10, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x46,
  2097  	0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x54, 0x0a, 0x0f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x5f,
  2098  	0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x72, 0x6f, 0x77, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a,
  2099  	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65,
  2100  	0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x65, 0x6c,
  2101  	0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x52, 0x6f, 0x77, 0x48, 0x00, 0x52, 0x0d, 0x64, 0x65,
  2102  	0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x52, 0x6f, 0x77, 0x1a, 0x96, 0x01, 0x0a, 0x07,
  2103  	0x53, 0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c,
  2104  	0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61,
  2105  	0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6c, 0x75,
  2106  	0x6d, 0x6e, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01,
  2107  	0x28, 0x0c, 0x52, 0x0f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66,
  2108  	0x69, 0x65, 0x72, 0x12, 0x29, 0x0a, 0x10, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
  2109  	0x5f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x74,
  2110  	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x12, 0x14,
  2111  	0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76,
  2112  	0x61, 0x6c, 0x75, 0x65, 0x1a, 0xa1, 0x01, 0x0a, 0x10, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46,
  2113  	0x72, 0x6f, 0x6d, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x6d,
  2114  	0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
  2115  	0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f,
  2116  	0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02,
  2117  	0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x51, 0x75, 0x61, 0x6c,
  2118  	0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x41, 0x0a, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x72, 0x61,
  2119  	0x6e, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
  2120  	0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54,
  2121  	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x09, 0x74,
  2122  	0x69, 0x6d, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x1a, 0x33, 0x0a, 0x10, 0x44, 0x65, 0x6c, 0x65,
  2123  	0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x1f, 0x0a, 0x0b,
  2124  	0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
  2125  	0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x1a, 0x0f, 0x0a,
  2126  	0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x52, 0x6f, 0x77, 0x42, 0x0a,
  2127  	0x0a, 0x08, 0x6d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xbb, 0x01, 0x0a, 0x13, 0x52,
  2128  	0x65, 0x61, 0x64, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x57, 0x72, 0x69, 0x74, 0x65, 0x52, 0x75,
  2129  	0x6c, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d,
  2130  	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e,
  2131  	0x61, 0x6d, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x71, 0x75,
  2132  	0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x63,
  2133  	0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x23,
  2134  	0x0a, 0x0c, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03,
  2135  	0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0b, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x56, 0x61,
  2136  	0x6c, 0x75, 0x65, 0x12, 0x2b, 0x0a, 0x10, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74,
  2137  	0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52,
  2138  	0x0f, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74,
  2139  	0x42, 0x06, 0x0a, 0x04, 0x72, 0x75, 0x6c, 0x65, 0x42, 0x69, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e,
  2140  	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e,
  2141  	0x76, 0x31, 0x42, 0x11, 0x42, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x44, 0x61, 0x74, 0x61,
  2142  	0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3a, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
  2143  	0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x67, 0x65, 0x6e, 0x70, 0x72,
  2144  	0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x61, 0x70, 0x69, 0x73, 0x2f, 0x62,
  2145  	0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x3b, 0x62, 0x69, 0x67, 0x74, 0x61,
  2146  	0x62, 0x6c, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
  2147  }
  2148  
  2149  var (
  2150  	file_google_bigtable_v1_bigtable_data_proto_rawDescOnce sync.Once
  2151  	file_google_bigtable_v1_bigtable_data_proto_rawDescData = file_google_bigtable_v1_bigtable_data_proto_rawDesc
  2152  )
  2153  
  2154  func file_google_bigtable_v1_bigtable_data_proto_rawDescGZIP() []byte {
  2155  	file_google_bigtable_v1_bigtable_data_proto_rawDescOnce.Do(func() {
  2156  		file_google_bigtable_v1_bigtable_data_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_bigtable_v1_bigtable_data_proto_rawDescData)
  2157  	})
  2158  	return file_google_bigtable_v1_bigtable_data_proto_rawDescData
  2159  }
  2160  
  2161  var file_google_bigtable_v1_bigtable_data_proto_msgTypes = make([]protoimpl.MessageInfo, 19)
  2162  var file_google_bigtable_v1_bigtable_data_proto_goTypes = []interface{}{
  2163  	(*Row)(nil),                       // 0: google.bigtable.v1.Row
  2164  	(*Family)(nil),                    // 1: google.bigtable.v1.Family
  2165  	(*Column)(nil),                    // 2: google.bigtable.v1.Column
  2166  	(*Cell)(nil),                      // 3: google.bigtable.v1.Cell
  2167  	(*RowRange)(nil),                  // 4: google.bigtable.v1.RowRange
  2168  	(*RowSet)(nil),                    // 5: google.bigtable.v1.RowSet
  2169  	(*ColumnRange)(nil),               // 6: google.bigtable.v1.ColumnRange
  2170  	(*TimestampRange)(nil),            // 7: google.bigtable.v1.TimestampRange
  2171  	(*ValueRange)(nil),                // 8: google.bigtable.v1.ValueRange
  2172  	(*RowFilter)(nil),                 // 9: google.bigtable.v1.RowFilter
  2173  	(*Mutation)(nil),                  // 10: google.bigtable.v1.Mutation
  2174  	(*ReadModifyWriteRule)(nil),       // 11: google.bigtable.v1.ReadModifyWriteRule
  2175  	(*RowFilter_Chain)(nil),           // 12: google.bigtable.v1.RowFilter.Chain
  2176  	(*RowFilter_Interleave)(nil),      // 13: google.bigtable.v1.RowFilter.Interleave
  2177  	(*RowFilter_Condition)(nil),       // 14: google.bigtable.v1.RowFilter.Condition
  2178  	(*Mutation_SetCell)(nil),          // 15: google.bigtable.v1.Mutation.SetCell
  2179  	(*Mutation_DeleteFromColumn)(nil), // 16: google.bigtable.v1.Mutation.DeleteFromColumn
  2180  	(*Mutation_DeleteFromFamily)(nil), // 17: google.bigtable.v1.Mutation.DeleteFromFamily
  2181  	(*Mutation_DeleteFromRow)(nil),    // 18: google.bigtable.v1.Mutation.DeleteFromRow
  2182  }
  2183  var file_google_bigtable_v1_bigtable_data_proto_depIdxs = []int32{
  2184  	1,  // 0: google.bigtable.v1.Row.families:type_name -> google.bigtable.v1.Family
  2185  	2,  // 1: google.bigtable.v1.Family.columns:type_name -> google.bigtable.v1.Column
  2186  	3,  // 2: google.bigtable.v1.Column.cells:type_name -> google.bigtable.v1.Cell
  2187  	4,  // 3: google.bigtable.v1.RowSet.row_ranges:type_name -> google.bigtable.v1.RowRange
  2188  	12, // 4: google.bigtable.v1.RowFilter.chain:type_name -> google.bigtable.v1.RowFilter.Chain
  2189  	13, // 5: google.bigtable.v1.RowFilter.interleave:type_name -> google.bigtable.v1.RowFilter.Interleave
  2190  	14, // 6: google.bigtable.v1.RowFilter.condition:type_name -> google.bigtable.v1.RowFilter.Condition
  2191  	6,  // 7: google.bigtable.v1.RowFilter.column_range_filter:type_name -> google.bigtable.v1.ColumnRange
  2192  	7,  // 8: google.bigtable.v1.RowFilter.timestamp_range_filter:type_name -> google.bigtable.v1.TimestampRange
  2193  	8,  // 9: google.bigtable.v1.RowFilter.value_range_filter:type_name -> google.bigtable.v1.ValueRange
  2194  	15, // 10: google.bigtable.v1.Mutation.set_cell:type_name -> google.bigtable.v1.Mutation.SetCell
  2195  	16, // 11: google.bigtable.v1.Mutation.delete_from_column:type_name -> google.bigtable.v1.Mutation.DeleteFromColumn
  2196  	17, // 12: google.bigtable.v1.Mutation.delete_from_family:type_name -> google.bigtable.v1.Mutation.DeleteFromFamily
  2197  	18, // 13: google.bigtable.v1.Mutation.delete_from_row:type_name -> google.bigtable.v1.Mutation.DeleteFromRow
  2198  	9,  // 14: google.bigtable.v1.RowFilter.Chain.filters:type_name -> google.bigtable.v1.RowFilter
  2199  	9,  // 15: google.bigtable.v1.RowFilter.Interleave.filters:type_name -> google.bigtable.v1.RowFilter
  2200  	9,  // 16: google.bigtable.v1.RowFilter.Condition.predicate_filter:type_name -> google.bigtable.v1.RowFilter
  2201  	9,  // 17: google.bigtable.v1.RowFilter.Condition.true_filter:type_name -> google.bigtable.v1.RowFilter
  2202  	9,  // 18: google.bigtable.v1.RowFilter.Condition.false_filter:type_name -> google.bigtable.v1.RowFilter
  2203  	7,  // 19: google.bigtable.v1.Mutation.DeleteFromColumn.time_range:type_name -> google.bigtable.v1.TimestampRange
  2204  	20, // [20:20] is the sub-list for method output_type
  2205  	20, // [20:20] is the sub-list for method input_type
  2206  	20, // [20:20] is the sub-list for extension type_name
  2207  	20, // [20:20] is the sub-list for extension extendee
  2208  	0,  // [0:20] is the sub-list for field type_name
  2209  }
  2210  
  2211  func init() { file_google_bigtable_v1_bigtable_data_proto_init() }
  2212  func file_google_bigtable_v1_bigtable_data_proto_init() {
  2213  	if File_google_bigtable_v1_bigtable_data_proto != nil {
  2214  		return
  2215  	}
  2216  	if !protoimpl.UnsafeEnabled {
  2217  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
  2218  			switch v := v.(*Row); i {
  2219  			case 0:
  2220  				return &v.state
  2221  			case 1:
  2222  				return &v.sizeCache
  2223  			case 2:
  2224  				return &v.unknownFields
  2225  			default:
  2226  				return nil
  2227  			}
  2228  		}
  2229  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
  2230  			switch v := v.(*Family); i {
  2231  			case 0:
  2232  				return &v.state
  2233  			case 1:
  2234  				return &v.sizeCache
  2235  			case 2:
  2236  				return &v.unknownFields
  2237  			default:
  2238  				return nil
  2239  			}
  2240  		}
  2241  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
  2242  			switch v := v.(*Column); i {
  2243  			case 0:
  2244  				return &v.state
  2245  			case 1:
  2246  				return &v.sizeCache
  2247  			case 2:
  2248  				return &v.unknownFields
  2249  			default:
  2250  				return nil
  2251  			}
  2252  		}
  2253  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
  2254  			switch v := v.(*Cell); i {
  2255  			case 0:
  2256  				return &v.state
  2257  			case 1:
  2258  				return &v.sizeCache
  2259  			case 2:
  2260  				return &v.unknownFields
  2261  			default:
  2262  				return nil
  2263  			}
  2264  		}
  2265  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
  2266  			switch v := v.(*RowRange); i {
  2267  			case 0:
  2268  				return &v.state
  2269  			case 1:
  2270  				return &v.sizeCache
  2271  			case 2:
  2272  				return &v.unknownFields
  2273  			default:
  2274  				return nil
  2275  			}
  2276  		}
  2277  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
  2278  			switch v := v.(*RowSet); i {
  2279  			case 0:
  2280  				return &v.state
  2281  			case 1:
  2282  				return &v.sizeCache
  2283  			case 2:
  2284  				return &v.unknownFields
  2285  			default:
  2286  				return nil
  2287  			}
  2288  		}
  2289  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
  2290  			switch v := v.(*ColumnRange); i {
  2291  			case 0:
  2292  				return &v.state
  2293  			case 1:
  2294  				return &v.sizeCache
  2295  			case 2:
  2296  				return &v.unknownFields
  2297  			default:
  2298  				return nil
  2299  			}
  2300  		}
  2301  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
  2302  			switch v := v.(*TimestampRange); i {
  2303  			case 0:
  2304  				return &v.state
  2305  			case 1:
  2306  				return &v.sizeCache
  2307  			case 2:
  2308  				return &v.unknownFields
  2309  			default:
  2310  				return nil
  2311  			}
  2312  		}
  2313  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
  2314  			switch v := v.(*ValueRange); i {
  2315  			case 0:
  2316  				return &v.state
  2317  			case 1:
  2318  				return &v.sizeCache
  2319  			case 2:
  2320  				return &v.unknownFields
  2321  			default:
  2322  				return nil
  2323  			}
  2324  		}
  2325  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
  2326  			switch v := v.(*RowFilter); i {
  2327  			case 0:
  2328  				return &v.state
  2329  			case 1:
  2330  				return &v.sizeCache
  2331  			case 2:
  2332  				return &v.unknownFields
  2333  			default:
  2334  				return nil
  2335  			}
  2336  		}
  2337  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
  2338  			switch v := v.(*Mutation); i {
  2339  			case 0:
  2340  				return &v.state
  2341  			case 1:
  2342  				return &v.sizeCache
  2343  			case 2:
  2344  				return &v.unknownFields
  2345  			default:
  2346  				return nil
  2347  			}
  2348  		}
  2349  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
  2350  			switch v := v.(*ReadModifyWriteRule); i {
  2351  			case 0:
  2352  				return &v.state
  2353  			case 1:
  2354  				return &v.sizeCache
  2355  			case 2:
  2356  				return &v.unknownFields
  2357  			default:
  2358  				return nil
  2359  			}
  2360  		}
  2361  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
  2362  			switch v := v.(*RowFilter_Chain); i {
  2363  			case 0:
  2364  				return &v.state
  2365  			case 1:
  2366  				return &v.sizeCache
  2367  			case 2:
  2368  				return &v.unknownFields
  2369  			default:
  2370  				return nil
  2371  			}
  2372  		}
  2373  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
  2374  			switch v := v.(*RowFilter_Interleave); i {
  2375  			case 0:
  2376  				return &v.state
  2377  			case 1:
  2378  				return &v.sizeCache
  2379  			case 2:
  2380  				return &v.unknownFields
  2381  			default:
  2382  				return nil
  2383  			}
  2384  		}
  2385  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
  2386  			switch v := v.(*RowFilter_Condition); i {
  2387  			case 0:
  2388  				return &v.state
  2389  			case 1:
  2390  				return &v.sizeCache
  2391  			case 2:
  2392  				return &v.unknownFields
  2393  			default:
  2394  				return nil
  2395  			}
  2396  		}
  2397  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
  2398  			switch v := v.(*Mutation_SetCell); i {
  2399  			case 0:
  2400  				return &v.state
  2401  			case 1:
  2402  				return &v.sizeCache
  2403  			case 2:
  2404  				return &v.unknownFields
  2405  			default:
  2406  				return nil
  2407  			}
  2408  		}
  2409  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
  2410  			switch v := v.(*Mutation_DeleteFromColumn); i {
  2411  			case 0:
  2412  				return &v.state
  2413  			case 1:
  2414  				return &v.sizeCache
  2415  			case 2:
  2416  				return &v.unknownFields
  2417  			default:
  2418  				return nil
  2419  			}
  2420  		}
  2421  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
  2422  			switch v := v.(*Mutation_DeleteFromFamily); i {
  2423  			case 0:
  2424  				return &v.state
  2425  			case 1:
  2426  				return &v.sizeCache
  2427  			case 2:
  2428  				return &v.unknownFields
  2429  			default:
  2430  				return nil
  2431  			}
  2432  		}
  2433  		file_google_bigtable_v1_bigtable_data_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
  2434  			switch v := v.(*Mutation_DeleteFromRow); i {
  2435  			case 0:
  2436  				return &v.state
  2437  			case 1:
  2438  				return &v.sizeCache
  2439  			case 2:
  2440  				return &v.unknownFields
  2441  			default:
  2442  				return nil
  2443  			}
  2444  		}
  2445  	}
  2446  	file_google_bigtable_v1_bigtable_data_proto_msgTypes[6].OneofWrappers = []interface{}{
  2447  		(*ColumnRange_StartQualifierInclusive)(nil),
  2448  		(*ColumnRange_StartQualifierExclusive)(nil),
  2449  		(*ColumnRange_EndQualifierInclusive)(nil),
  2450  		(*ColumnRange_EndQualifierExclusive)(nil),
  2451  	}
  2452  	file_google_bigtable_v1_bigtable_data_proto_msgTypes[8].OneofWrappers = []interface{}{
  2453  		(*ValueRange_StartValueInclusive)(nil),
  2454  		(*ValueRange_StartValueExclusive)(nil),
  2455  		(*ValueRange_EndValueInclusive)(nil),
  2456  		(*ValueRange_EndValueExclusive)(nil),
  2457  	}
  2458  	file_google_bigtable_v1_bigtable_data_proto_msgTypes[9].OneofWrappers = []interface{}{
  2459  		(*RowFilter_Chain_)(nil),
  2460  		(*RowFilter_Interleave_)(nil),
  2461  		(*RowFilter_Condition_)(nil),
  2462  		(*RowFilter_Sink)(nil),
  2463  		(*RowFilter_PassAllFilter)(nil),
  2464  		(*RowFilter_BlockAllFilter)(nil),
  2465  		(*RowFilter_RowKeyRegexFilter)(nil),
  2466  		(*RowFilter_RowSampleFilter)(nil),
  2467  		(*RowFilter_FamilyNameRegexFilter)(nil),
  2468  		(*RowFilter_ColumnQualifierRegexFilter)(nil),
  2469  		(*RowFilter_ColumnRangeFilter)(nil),
  2470  		(*RowFilter_TimestampRangeFilter)(nil),
  2471  		(*RowFilter_ValueRegexFilter)(nil),
  2472  		(*RowFilter_ValueRangeFilter)(nil),
  2473  		(*RowFilter_CellsPerRowOffsetFilter)(nil),
  2474  		(*RowFilter_CellsPerRowLimitFilter)(nil),
  2475  		(*RowFilter_CellsPerColumnLimitFilter)(nil),
  2476  		(*RowFilter_StripValueTransformer)(nil),
  2477  		(*RowFilter_ApplyLabelTransformer)(nil),
  2478  	}
  2479  	file_google_bigtable_v1_bigtable_data_proto_msgTypes[10].OneofWrappers = []interface{}{
  2480  		(*Mutation_SetCell_)(nil),
  2481  		(*Mutation_DeleteFromColumn_)(nil),
  2482  		(*Mutation_DeleteFromFamily_)(nil),
  2483  		(*Mutation_DeleteFromRow_)(nil),
  2484  	}
  2485  	file_google_bigtable_v1_bigtable_data_proto_msgTypes[11].OneofWrappers = []interface{}{
  2486  		(*ReadModifyWriteRule_AppendValue)(nil),
  2487  		(*ReadModifyWriteRule_IncrementAmount)(nil),
  2488  	}
  2489  	type x struct{}
  2490  	out := protoimpl.TypeBuilder{
  2491  		File: protoimpl.DescBuilder{
  2492  			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
  2493  			RawDescriptor: file_google_bigtable_v1_bigtable_data_proto_rawDesc,
  2494  			NumEnums:      0,
  2495  			NumMessages:   19,
  2496  			NumExtensions: 0,
  2497  			NumServices:   0,
  2498  		},
  2499  		GoTypes:           file_google_bigtable_v1_bigtable_data_proto_goTypes,
  2500  		DependencyIndexes: file_google_bigtable_v1_bigtable_data_proto_depIdxs,
  2501  		MessageInfos:      file_google_bigtable_v1_bigtable_data_proto_msgTypes,
  2502  	}.Build()
  2503  	File_google_bigtable_v1_bigtable_data_proto = out.File
  2504  	file_google_bigtable_v1_bigtable_data_proto_rawDesc = nil
  2505  	file_google_bigtable_v1_bigtable_data_proto_goTypes = nil
  2506  	file_google_bigtable_v1_bigtable_data_proto_depIdxs = nil
  2507  }
  2508  

View as plain text