bigtable

type BigtableClient interface {
	// Streams back the contents of all requested rows in key order, optionally
	// applying the same Reader filter to each. Depending on their size,
	// rows and cells may be broken up across multiple responses, but
	// atomicity of each row will still be preserved. See the
	// ReadRowsResponse documentation for details.
	ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (Bigtable_ReadRowsClient, error)
	// Returns a sample of row keys in the table. The returned row keys will
	// delimit contiguous sections of the table of approximately equal size,
	// which can be used to break up the data for distributed tasks like
	// mapreduces.
	SampleRowKeys(ctx context.Context, in *SampleRowKeysRequest, opts ...grpc.CallOption) (Bigtable_SampleRowKeysClient, error)
	// Mutates a row atomically. Cells already present in the row are left
	// unchanged unless explicitly changed by `mutation`.
	MutateRow(ctx context.Context, in *MutateRowRequest, opts ...grpc.CallOption) (*MutateRowResponse, error)
	// Mutates multiple rows in a batch. Each individual row is mutated
	// atomically as in MutateRow, but the entire batch is not executed
	// atomically.
	MutateRows(ctx context.Context, in *MutateRowsRequest, opts ...grpc.CallOption) (Bigtable_MutateRowsClient, error)
	// Mutates a row atomically based on the output of a predicate Reader filter.
	CheckAndMutateRow(ctx context.Context, in *CheckAndMutateRowRequest, opts ...grpc.CallOption) (*CheckAndMutateRowResponse, error)
	// Warm up associated instance metadata for this connection.
	// This call is not required but may be useful for connection keep-alive.
	PingAndWarm(ctx context.Context, in *PingAndWarmRequest, opts ...grpc.CallOption) (*PingAndWarmResponse, error)
	// Modifies a row atomically on the server. The method reads the latest
	// existing timestamp and value from the specified columns and writes a new
	// entry based on pre-defined read/modify/write rules. The new value for the
	// timestamp is the greater of the existing timestamp or the current server
	// time. The method returns the new contents of all modified cells.
	ReadModifyWriteRow(ctx context.Context, in *ReadModifyWriteRowRequest, opts ...grpc.CallOption) (*ReadModifyWriteRowResponse, error)
	// NOTE: This API is intended to be used by Apache Beam BigtableIO.
	// Returns the current list of partitions that make up the table's
	// change stream. The union of partitions will cover the entire keyspace.
	// Partitions can be read with `ReadChangeStream`.
	GenerateInitialChangeStreamPartitions(ctx context.Context, in *GenerateInitialChangeStreamPartitionsRequest, opts ...grpc.CallOption) (Bigtable_GenerateInitialChangeStreamPartitionsClient, error)
	// NOTE: This API is intended to be used by Apache Beam BigtableIO.
	// Reads changes from a table's change stream. Changes will
	// reflect both user-initiated mutations and mutations that are caused by
	// garbage collection.
	ReadChangeStream(ctx context.Context, in *ReadChangeStreamRequest, opts ...grpc.CallOption) (Bigtable_ReadChangeStreamClient, error)
}

type BigtableServer interface {
	// Streams back the contents of all requested rows in key order, optionally
	// applying the same Reader filter to each. Depending on their size,
	// rows and cells may be broken up across multiple responses, but
	// atomicity of each row will still be preserved. See the
	// ReadRowsResponse documentation for details.
	ReadRows(*ReadRowsRequest, Bigtable_ReadRowsServer) error
	// Returns a sample of row keys in the table. The returned row keys will
	// delimit contiguous sections of the table of approximately equal size,
	// which can be used to break up the data for distributed tasks like
	// mapreduces.
	SampleRowKeys(*SampleRowKeysRequest, Bigtable_SampleRowKeysServer) error
	// Mutates a row atomically. Cells already present in the row are left
	// unchanged unless explicitly changed by `mutation`.
	MutateRow(context.Context, *MutateRowRequest) (*MutateRowResponse, error)
	// Mutates multiple rows in a batch. Each individual row is mutated
	// atomically as in MutateRow, but the entire batch is not executed
	// atomically.
	MutateRows(*MutateRowsRequest, Bigtable_MutateRowsServer) error
	// Mutates a row atomically based on the output of a predicate Reader filter.
	CheckAndMutateRow(context.Context, *CheckAndMutateRowRequest) (*CheckAndMutateRowResponse, error)
	// Warm up associated instance metadata for this connection.
	// This call is not required but may be useful for connection keep-alive.
	PingAndWarm(context.Context, *PingAndWarmRequest) (*PingAndWarmResponse, error)
	// Modifies a row atomically on the server. The method reads the latest
	// existing timestamp and value from the specified columns and writes a new
	// entry based on pre-defined read/modify/write rules. The new value for the
	// timestamp is the greater of the existing timestamp or the current server
	// time. The method returns the new contents of all modified cells.
	ReadModifyWriteRow(context.Context, *ReadModifyWriteRowRequest) (*ReadModifyWriteRowResponse, error)
	// NOTE: This API is intended to be used by Apache Beam BigtableIO.
	// Returns the current list of partitions that make up the table's
	// change stream. The union of partitions will cover the entire keyspace.
	// Partitions can be read with `ReadChangeStream`.
	GenerateInitialChangeStreamPartitions(*GenerateInitialChangeStreamPartitionsRequest, Bigtable_GenerateInitialChangeStreamPartitionsServer) error
	// NOTE: This API is intended to be used by Apache Beam BigtableIO.
	// Reads changes from a table's change stream. Changes will
	// reflect both user-initiated mutations and mutations that are caused by
	// garbage collection.
	ReadChangeStream(*ReadChangeStreamRequest, Bigtable_ReadChangeStreamServer) error
}

type Bigtable_GenerateInitialChangeStreamPartitionsClient interface {
	Recv() (*GenerateInitialChangeStreamPartitionsResponse, error)
	grpc.ClientStream
}

type Bigtable_GenerateInitialChangeStreamPartitionsServer interface {
	Send(*GenerateInitialChangeStreamPartitionsResponse) error
	grpc.ServerStream
}

type Bigtable_MutateRowsClient interface {
	Recv() (*MutateRowsResponse, error)
	grpc.ClientStream
}

type Bigtable_MutateRowsServer interface {
	Send(*MutateRowsResponse) error
	grpc.ServerStream
}

type Bigtable_ReadChangeStreamClient interface {
	Recv() (*ReadChangeStreamResponse, error)
	grpc.ClientStream
}

type Bigtable_ReadChangeStreamServer interface {
	Send(*ReadChangeStreamResponse) error
	grpc.ServerStream
}

type Bigtable_ReadRowsClient interface {
	Recv() (*ReadRowsResponse, error)
	grpc.ClientStream
}

type Bigtable_ReadRowsServer interface {
	Send(*ReadRowsResponse) error
	grpc.ServerStream
}

type Bigtable_SampleRowKeysClient interface {
	Recv() (*SampleRowKeysResponse, error)
	grpc.ClientStream
}

type Bigtable_SampleRowKeysServer interface {
	Send(*SampleRowKeysResponse) error
	grpc.ServerStream
}

type Cell struct {

	// The cell's stored timestamp, which also uniquely identifies it within
	// its column.
	// Values are always expressed in microseconds, but individual tables may set
	// a coarser granularity to further restrict the allowed values. For
	// example, a table which specifies millisecond granularity will only allow
	// values of `timestamp_micros` which are multiples of 1000.
	TimestampMicros int64 `protobuf:"varint,1,opt,name=timestamp_micros,json=timestampMicros,proto3" json:"timestamp_micros,omitempty"`
	// The value stored in the cell.
	// May contain any byte string, including the empty string, up to 100MiB in
	// length.
	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// Labels applied to the cell by a [RowFilter][google.bigtable.v2.RowFilter].
	Labels []string `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty"`
	// contains filtered or unexported fields
}

type CheckAndMutateRowRequest struct {

	// Optional. The unique name of the table to which the conditional mutation
	// should be applied.
	//
	// Values are of the form
	// `projects/<project>/instances/<instance>/tables/<table>`.
	TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
	// Optional. The unique name of the AuthorizedView to which the conditional
	// mutation should be applied.
	//
	// Values are of the form
	// `projects/<project>/instances/<instance>/tables/<table>/authorizedViews/<authorized_view>`.
	AuthorizedViewName string `protobuf:"bytes,9,opt,name=authorized_view_name,json=authorizedViewName,proto3" json:"authorized_view_name,omitempty"`
	// This value specifies routing for replication. If not specified, the
	// "default" application profile will be used.
	AppProfileId string `protobuf:"bytes,7,opt,name=app_profile_id,json=appProfileId,proto3" json:"app_profile_id,omitempty"`
	// Required. The key of the row to which the conditional mutation should be
	// applied.
	RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
	// The filter to be applied to the contents of the specified row. Depending
	// on whether or not any results are yielded, either `true_mutations` or
	// `false_mutations` will be executed. If unset, checks that the row contains
	// any values at all.
	PredicateFilter *RowFilter `protobuf:"bytes,6,opt,name=predicate_filter,json=predicateFilter,proto3" json:"predicate_filter,omitempty"`
	// Changes to be atomically applied to the specified row if `predicate_filter`
	// yields at least one cell when applied to `row_key`. Entries are applied in
	// order, meaning that earlier mutations can be masked by later ones.
	// Must contain at least one entry if `false_mutations` is empty, and at most
	// 100000.
	TrueMutations []*Mutation `protobuf:"bytes,4,rep,name=true_mutations,json=trueMutations,proto3" json:"true_mutations,omitempty"`
	// Changes to be atomically applied to the specified row if `predicate_filter`
	// does not yield any cells when applied to `row_key`. Entries are applied in
	// order, meaning that earlier mutations can be masked by later ones.
	// Must contain at least one entry if `true_mutations` is empty, and at most
	// 100000.
	FalseMutations []*Mutation `protobuf:"bytes,5,rep,name=false_mutations,json=falseMutations,proto3" json:"false_mutations,omitempty"`
	// contains filtered or unexported fields
}

type CheckAndMutateRowResponse struct {

	// Whether or not the request's `predicate_filter` yielded any results for
	// the specified row.
	PredicateMatched bool `protobuf:"varint,1,opt,name=predicate_matched,json=predicateMatched,proto3" json:"predicate_matched,omitempty"`
	// contains filtered or unexported fields
}

type Column struct {

	// The unique key which identifies this column within its family. This is the
	// same key that's used to identify the column in, for example, a RowFilter
	// which sets its `column_qualifier_regex_filter` field.
	// May contain any byte string, including the empty string, up to 16kiB in
	// length.
	Qualifier []byte `protobuf:"bytes,1,opt,name=qualifier,proto3" json:"qualifier,omitempty"`
	// Must not be empty. Sorted in order of decreasing "timestamp_micros".
	Cells []*Cell `protobuf:"bytes,2,rep,name=cells,proto3" json:"cells,omitempty"`
	// contains filtered or unexported fields
}

type ColumnRange struct {

	// The name of the column family within which this range falls.
	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
	// The column qualifier at which to start the range (within `column_family`).
	// If neither field is set, interpreted as the empty string, inclusive.
	//
	// Types that are assignable to StartQualifier:
	//
	//	*ColumnRange_StartQualifierClosed
	//	*ColumnRange_StartQualifierOpen
	StartQualifier isColumnRange_StartQualifier `protobuf_oneof:"start_qualifier"`
	// The column qualifier at which to end the range (within `column_family`).
	// If neither field is set, interpreted as the infinite string, exclusive.
	//
	// Types that are assignable to EndQualifier:
	//
	//	*ColumnRange_EndQualifierClosed
	//	*ColumnRange_EndQualifierOpen
	EndQualifier isColumnRange_EndQualifier `protobuf_oneof:"end_qualifier"`
	// contains filtered or unexported fields
}

type ColumnRange_EndQualifierClosed struct {
	// Used when giving an inclusive upper bound for the range.
	EndQualifierClosed []byte `protobuf:"bytes,4,opt,name=end_qualifier_closed,json=endQualifierClosed,proto3,oneof"`
}

type ColumnRange_EndQualifierOpen struct {
	// Used when giving an exclusive upper bound for the range.
	EndQualifierOpen []byte `protobuf:"bytes,5,opt,name=end_qualifier_open,json=endQualifierOpen,proto3,oneof"`
}

type ColumnRange_StartQualifierClosed struct {
	// Used when giving an inclusive lower bound for the range.
	StartQualifierClosed []byte `protobuf:"bytes,2,opt,name=start_qualifier_closed,json=startQualifierClosed,proto3,oneof"`
}

type ColumnRange_StartQualifierOpen struct {
	// Used when giving an exclusive lower bound for the range.
	StartQualifierOpen []byte `protobuf:"bytes,3,opt,name=start_qualifier_open,json=startQualifierOpen,proto3,oneof"`
}

type Family struct {

	// The unique key which identifies this family within its row. This is the
	// same key that's used to identify the family in, for example, a RowFilter
	// which sets its "family_name_regex_filter" field.
	// Must match `[-_.a-zA-Z0-9]+`, except that AggregatingRowProcessors may
	// produce cells in a sentinel family with an empty name.
	// Must be no greater than 64 characters in length.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Must not be empty. Sorted in order of increasing "qualifier".
	Columns []*Column `protobuf:"bytes,2,rep,name=columns,proto3" json:"columns,omitempty"`
	// contains filtered or unexported fields
}

type FeatureFlags struct {

	// Notify the server that the client supports reverse scans. The server will
	// reject ReadRowsRequests with the reverse bit set when this is absent.
	ReverseScans bool `protobuf:"varint,1,opt,name=reverse_scans,json=reverseScans,proto3" json:"reverse_scans,omitempty"`
	// Notify the server that the client enables batch write flow control by
	// requesting RateLimitInfo from MutateRowsResponse. Due to technical reasons,
	// this disables partial retries.
	MutateRowsRateLimit bool `protobuf:"varint,3,opt,name=mutate_rows_rate_limit,json=mutateRowsRateLimit,proto3" json:"mutate_rows_rate_limit,omitempty"`
	// Notify the server that the client enables batch write flow control by
	// requesting RateLimitInfo from MutateRowsResponse. With partial retries
	// enabled.
	MutateRowsRateLimit2 bool `` /* 126-byte string literal not displayed */
	// Notify the server that the client supports the last_scanned_row field
	// in ReadRowsResponse for long-running scans.
	LastScannedRowResponses bool `` /* 135-byte string literal not displayed */
	// Notify the server that the client supports using encoded routing cookie
	// strings to retry requests with.
	RoutingCookie bool `protobuf:"varint,6,opt,name=routing_cookie,json=routingCookie,proto3" json:"routing_cookie,omitempty"`
	// Notify the server that the client supports using retry info back off
	// durations to retry requests with.
	RetryInfo bool `protobuf:"varint,7,opt,name=retry_info,json=retryInfo,proto3" json:"retry_info,omitempty"`
	// Notify the server that the client has client side metrics enabled.
	ClientSideMetricsEnabled bool `` /* 138-byte string literal not displayed */
	// contains filtered or unexported fields
}

type FullReadStatsView struct {

	// Iteration stats describe how efficient the read is, e.g. comparing
	// rows seen vs. rows returned or cells seen vs cells returned can provide an
	// indication of read efficiency (the higher the ratio of seen to retuned the
	// better).
	ReadIterationStats *ReadIterationStats `protobuf:"bytes,1,opt,name=read_iteration_stats,json=readIterationStats,proto3" json:"read_iteration_stats,omitempty"`
	// Request latency stats describe the time taken to complete a request, from
	// the server side.
	RequestLatencyStats *RequestLatencyStats `protobuf:"bytes,2,opt,name=request_latency_stats,json=requestLatencyStats,proto3" json:"request_latency_stats,omitempty"`
	// contains filtered or unexported fields
}

type GenerateInitialChangeStreamPartitionsRequest struct {

	// Required. The unique name of the table from which to get change stream
	// partitions. Values are of the form
	// `projects/<project>/instances/<instance>/tables/<table>`.
	// Change streaming must be enabled on the table.
	TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
	// This value specifies routing for replication. If not specified, the
	// "default" application profile will be used.
	// Single cluster routing must be configured on the profile.
	AppProfileId string `protobuf:"bytes,2,opt,name=app_profile_id,json=appProfileId,proto3" json:"app_profile_id,omitempty"`
	// contains filtered or unexported fields
}

type GenerateInitialChangeStreamPartitionsResponse struct {

	// A partition of the change stream.
	Partition *StreamPartition `protobuf:"bytes,1,opt,name=partition,proto3" json:"partition,omitempty"`
	// contains filtered or unexported fields
}

type MutateRowRequest struct {

	// Optional. The unique name of the table to which the mutation should be
	// applied.
	//
	// Values are of the form
	// `projects/<project>/instances/<instance>/tables/<table>`.
	TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
	// Optional. The unique name of the AuthorizedView to which the mutation
	// should be applied.
	//
	// Values are of the form
	// `projects/<project>/instances/<instance>/tables/<table>/authorizedViews/<authorized_view>`.
	AuthorizedViewName string `protobuf:"bytes,6,opt,name=authorized_view_name,json=authorizedViewName,proto3" json:"authorized_view_name,omitempty"`
	// This value specifies routing for replication. If not specified, the
	// "default" application profile will be used.
	AppProfileId string `protobuf:"bytes,4,opt,name=app_profile_id,json=appProfileId,proto3" json:"app_profile_id,omitempty"`
	// Required. The key of the row to which the mutation should be applied.
	RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
	// Required. Changes to be atomically applied to the specified row. Entries
	// are applied in order, meaning that earlier mutations can be masked by later
	// ones. Must contain at least one entry and at most 100000.
	Mutations []*Mutation `protobuf:"bytes,3,rep,name=mutations,proto3" json:"mutations,omitempty"`
	// contains filtered or unexported fields
}

type MutateRowResponse struct {
	// contains filtered or unexported fields
}

type MutateRowsRequest struct {

	// Optional. The unique name of the table to which the mutations should be
	// applied.
	//
	// Values are of the form
	// `projects/<project>/instances/<instance>/tables/<table>`.
	TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
	// Optional. The unique name of the AuthorizedView to which the mutations
	// should be applied.
	//
	// Values are of the form
	// `projects/<project>/instances/<instance>/tables/<table>/authorizedViews/<authorized_view>`.
	AuthorizedViewName string `protobuf:"bytes,5,opt,name=authorized_view_name,json=authorizedViewName,proto3" json:"authorized_view_name,omitempty"`
	// This value specifies routing for replication. If not specified, the
	// "default" application profile will be used.
	AppProfileId string `protobuf:"bytes,3,opt,name=app_profile_id,json=appProfileId,proto3" json:"app_profile_id,omitempty"`
	// Required. The row keys and corresponding mutations to be applied in bulk.
	// Each entry is applied as an atomic mutation, but the entries may be
	// applied in arbitrary order (even between entries for the same row).
	// At least one entry must be specified, and in total the entries can
	// contain at most 100000 mutations.
	Entries []*MutateRowsRequest_Entry `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries,omitempty"`
	// contains filtered or unexported fields
}

type MutateRowsRequest_Entry struct {

	// The key of the row to which the `mutations` should be applied.
	RowKey []byte `protobuf:"bytes,1,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
	// Required. Changes to be atomically applied to the specified row.
	// Mutations are applied in order, meaning that earlier mutations can be
	// masked by later ones. You must specify at least one mutation.
	Mutations []*Mutation `protobuf:"bytes,2,rep,name=mutations,proto3" json:"mutations,omitempty"`
	// contains filtered or unexported fields
}

type MutateRowsResponse struct {

	// One or more results for Entries from the batch request.
	Entries []*MutateRowsResponse_Entry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	// Information about how client should limit the rate (QPS). Primirily used by
	// supported official Cloud Bigtable clients. If unset, the rate limit info is
	// not provided by the server.
	RateLimitInfo *RateLimitInfo `protobuf:"bytes,3,opt,name=rate_limit_info,json=rateLimitInfo,proto3,oneof" json:"rate_limit_info,omitempty"`
	// contains filtered or unexported fields
}

type MutateRowsResponse_Entry struct {

	// The index into the original request's `entries` list of the Entry
	// for which a result is being reported.
	Index int64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	// The result of the request Entry identified by `index`.
	// Depending on how requests are batched during execution, it is possible
	// for one Entry to fail due to an error with another Entry. In the event
	// that this occurs, the same error will be reported for both entries.
	Status *status.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// contains filtered or unexported fields
}

type Mutation struct {

	// Which of the possible Mutation types to apply.
	//
	// Types that are assignable to Mutation:
	//
	//	*Mutation_SetCell_
	//	*Mutation_AddToCell_
	//	*Mutation_DeleteFromColumn_
	//	*Mutation_DeleteFromFamily_
	//	*Mutation_DeleteFromRow_
	Mutation isMutation_Mutation `protobuf_oneof:"mutation"`
	// contains filtered or unexported fields
}

type Mutation_AddToCell struct {

	// The name of the `Aggregate` family into which new data should be added.
	// This must be a family with a `value_type` of `Aggregate`.
	// Format: `[-_.a-zA-Z0-9]+`
	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
	// The qualifier of the column into which new data should be added. This
	// must be a `raw_value`.
	ColumnQualifier *Value `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
	// The timestamp of the cell to which new data should be added. This must
	// be a `raw_timestamp_micros` that matches the table's `granularity`.
	Timestamp *Value `protobuf:"bytes,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// The input value to be accumulated into the specified cell. This must be
	// compatible with the family's `value_type.input_type`.
	Input *Value `protobuf:"bytes,4,opt,name=input,proto3" json:"input,omitempty"`
	// contains filtered or unexported fields
}

type Mutation_AddToCell_ struct {
	// Incrementally updates an `Aggregate` cell.
	AddToCell *Mutation_AddToCell `protobuf:"bytes,5,opt,name=add_to_cell,json=addToCell,proto3,oneof"`
}

type Mutation_DeleteFromColumn struct {

	// The name of the family from which cells should be deleted.
	// Must match `[-_.a-zA-Z0-9]+`
	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
	// The qualifier of the column from which cells should be deleted.
	// Can be any byte string, including the empty string.
	ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
	// The range of timestamps within which cells should be deleted.
	TimeRange *TimestampRange `protobuf:"bytes,3,opt,name=time_range,json=timeRange,proto3" json:"time_range,omitempty"`
	// contains filtered or unexported fields
}

type Mutation_DeleteFromColumn_ struct {
	// Deletes cells from a column.
	DeleteFromColumn *Mutation_DeleteFromColumn `protobuf:"bytes,2,opt,name=delete_from_column,json=deleteFromColumn,proto3,oneof"`
}

type Mutation_DeleteFromFamily struct {

	// The name of the family from which cells should be deleted.
	// Must match `[-_.a-zA-Z0-9]+`
	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
	// contains filtered or unexported fields
}

type Mutation_DeleteFromFamily_ struct {
	// Deletes cells from a column family.
	DeleteFromFamily *Mutation_DeleteFromFamily `protobuf:"bytes,3,opt,name=delete_from_family,json=deleteFromFamily,proto3,oneof"`
}

type Mutation_DeleteFromRow struct {
	// contains filtered or unexported fields
}

type Mutation_DeleteFromRow_ struct {
	// Deletes cells from the entire row.
	DeleteFromRow *Mutation_DeleteFromRow `protobuf:"bytes,4,opt,name=delete_from_row,json=deleteFromRow,proto3,oneof"`
}

type Mutation_SetCell struct {

	// The name of the family into which new data should be written.
	// Must match `[-_.a-zA-Z0-9]+`
	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
	// The qualifier of the column into which new data should be written.
	// Can be any byte string, including the empty string.
	ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
	// The timestamp of the cell into which new data should be written.
	// Use -1 for current Bigtable server time.
	// Otherwise, the client should set this value itself, noting that the
	// default value is a timestamp of zero if the field is left unspecified.
	// Values must match the granularity of the table (e.g. micros, millis).
	TimestampMicros int64 `protobuf:"varint,3,opt,name=timestamp_micros,json=timestampMicros,proto3" json:"timestamp_micros,omitempty"`
	// The value to be written into the specified cell.
	Value []byte `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type Mutation_SetCell_ struct {
	// Set a cell's value.
	SetCell *Mutation_SetCell `protobuf:"bytes,1,opt,name=set_cell,json=setCell,proto3,oneof"`
}

type PingAndWarmRequest struct {

	// Required. The unique name of the instance to check permissions for as well
	// as respond. Values are of the form
	// `projects/<project>/instances/<instance>`.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// This value specifies routing for replication. If not specified, the
	// "default" application profile will be used.
	AppProfileId string `protobuf:"bytes,2,opt,name=app_profile_id,json=appProfileId,proto3" json:"app_profile_id,omitempty"`
	// contains filtered or unexported fields
}

type PingAndWarmResponse struct {
	// contains filtered or unexported fields
}

type RateLimitInfo struct {

	// Time that clients should wait before adjusting the target rate again.
	// If clients adjust rate too frequently, the impact of the previous
	// adjustment may not have been taken into account and may
	// over-throttle or under-throttle. If clients adjust rate too slowly, they
	// will not be responsive to load changes on server side, and may
	// over-throttle or under-throttle.
	Period *durationpb.Duration `protobuf:"bytes,1,opt,name=period,proto3" json:"period,omitempty"`
	// If it has been at least one `period` since the last load adjustment, the
	// client should multiply the current load by this value to get the new target
	// load. For example, if the current load is 100 and `factor` is 0.8, the new
	// target load should be 80. After adjusting, the client should ignore
	// `factor` until another `period` has passed.
	//
	// The client can measure its load using any unit that's comparable over time
	// For example, QPS can be used as long as each request involves a similar
	// amount of work.
	Factor float64 `protobuf:"fixed64,2,opt,name=factor,proto3" json:"factor,omitempty"`
	// contains filtered or unexported fields
}

type ReadChangeStreamRequest struct {

	// Required. The unique name of the table from which to read a change stream.
	// Values are of the form
	// `projects/<project>/instances/<instance>/tables/<table>`.
	// Change streaming must be enabled on the table.
	TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
	// This value specifies routing for replication. If not specified, the
	// "default" application profile will be used.
	// Single cluster routing must be configured on the profile.
	AppProfileId string `protobuf:"bytes,2,opt,name=app_profile_id,json=appProfileId,proto3" json:"app_profile_id,omitempty"`
	// The partition to read changes from.
	Partition *StreamPartition `protobuf:"bytes,3,opt,name=partition,proto3" json:"partition,omitempty"`
	// Options for describing where we want to start reading from the stream.
	//
	// Types that are assignable to StartFrom:
	//
	//	*ReadChangeStreamRequest_StartTime
	//	*ReadChangeStreamRequest_ContinuationTokens
	StartFrom isReadChangeStreamRequest_StartFrom `protobuf_oneof:"start_from"`
	// If specified, OK will be returned when the stream advances beyond
	// this time. Otherwise, changes will be continuously delivered on the stream.
	// This value is inclusive and will be truncated to microsecond granularity.
	EndTime *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	// If specified, the duration between `Heartbeat` messages on the stream.
	// Otherwise, defaults to 5 seconds.
	HeartbeatDuration *durationpb.Duration `protobuf:"bytes,7,opt,name=heartbeat_duration,json=heartbeatDuration,proto3" json:"heartbeat_duration,omitempty"`
	// contains filtered or unexported fields
}

type ReadChangeStreamRequest_ContinuationTokens struct {
	// Tokens that describe how to resume reading a stream where reading
	// previously left off. If specified, changes will be read starting at the
	// the position. Tokens are delivered on the stream as part of `Heartbeat`
	// and `CloseStream` messages.
	//
	// If a single token is provided, the token’s partition must exactly match
	// the request’s partition. If multiple tokens are provided, as in the case
	// of a partition merge, the union of the token partitions must exactly
	// cover the request’s partition. Otherwise, INVALID_ARGUMENT will be
	// returned.
	ContinuationTokens *StreamContinuationTokens `protobuf:"bytes,6,opt,name=continuation_tokens,json=continuationTokens,proto3,oneof"`
}

type ReadChangeStreamRequest_StartTime struct {
	// Start reading the stream at the specified timestamp. This timestamp must
	// be within the change stream retention period, less than or equal to the
	// current time, and after change stream creation, whichever is greater.
	// This value is inclusive and will be truncated to microsecond granularity.
	StartTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=start_time,json=startTime,proto3,oneof"`
}

type ReadChangeStreamResponse struct {

	// The data or control message on the stream.
	//
	// Types that are assignable to StreamRecord:
	//
	//	*ReadChangeStreamResponse_DataChange_
	//	*ReadChangeStreamResponse_Heartbeat_
	//	*ReadChangeStreamResponse_CloseStream_
	StreamRecord isReadChangeStreamResponse_StreamRecord `protobuf_oneof:"stream_record"`
	// contains filtered or unexported fields
}

type ReadChangeStreamResponse_CloseStream struct {

	// The status of the stream.
	Status *status.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	// If non-empty, contains the information needed to resume reading their
	// associated partitions.
	ContinuationTokens []*StreamContinuationToken `protobuf:"bytes,2,rep,name=continuation_tokens,json=continuationTokens,proto3" json:"continuation_tokens,omitempty"`
	// If non-empty, contains the new partitions to start reading from, which
	// are related to but not necessarily identical to the partitions for the
	// above `continuation_tokens`.
	NewPartitions []*StreamPartition `protobuf:"bytes,3,rep,name=new_partitions,json=newPartitions,proto3" json:"new_partitions,omitempty"`
	// contains filtered or unexported fields
}

type ReadChangeStreamResponse_CloseStream_ struct {
	// An indication that the stream should be closed.
	CloseStream *ReadChangeStreamResponse_CloseStream `protobuf:"bytes,3,opt,name=close_stream,json=closeStream,proto3,oneof"`
}

type ReadChangeStreamResponse_DataChange struct {

	// The type of the mutation.
	Type ReadChangeStreamResponse_DataChange_Type `` /* 127-byte string literal not displayed */
	// The cluster where the mutation was applied.
	// Not set when `type` is `GARBAGE_COLLECTION`.
	SourceClusterId string `protobuf:"bytes,2,opt,name=source_cluster_id,json=sourceClusterId,proto3" json:"source_cluster_id,omitempty"`
	// The row key for all mutations that are part of this `DataChange`.
	// If the `DataChange` is chunked across multiple messages, then this field
	// will only be set for the first message.
	RowKey []byte `protobuf:"bytes,3,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
	// The timestamp at which the mutation was applied on the Bigtable server.
	CommitTimestamp *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=commit_timestamp,json=commitTimestamp,proto3" json:"commit_timestamp,omitempty"`
	// A value that lets stream consumers reconstruct Bigtable's
	// conflict resolution semantics.
	// https://cloud.google.com/bigtable/docs/writes#conflict-resolution
	// In the event that the same row key, column family, column qualifier,
	// timestamp are modified on different clusters at the same
	// `commit_timestamp`, the mutation with the larger `tiebreaker` will be the
	// one chosen for the eventually consistent state of the system.
	Tiebreaker int32 `protobuf:"varint,5,opt,name=tiebreaker,proto3" json:"tiebreaker,omitempty"`
	// The mutations associated with this change to the partition.
	// May contain complete mutations or chunks of a multi-message chunked
	// `DataChange` record.
	Chunks []*ReadChangeStreamResponse_MutationChunk `protobuf:"bytes,6,rep,name=chunks,proto3" json:"chunks,omitempty"`
	// When true, indicates that the entire `DataChange` has been read
	// and the client can safely process the message.
	Done bool `protobuf:"varint,8,opt,name=done,proto3" json:"done,omitempty"`
	// An encoded position for this stream's partition to restart reading from.
	// This token is for the StreamPartition from the request.
	Token string `protobuf:"bytes,9,opt,name=token,proto3" json:"token,omitempty"`
	// An estimate of the commit timestamp that is usually lower than or equal
	// to any timestamp for a record that will be delivered in the future on the
	// stream. It is possible that, under particular circumstances that a future
	// record has a timestamp is is lower than a previously seen timestamp. For
	// an example usage see
	// https://beam.apache.org/documentation/basics/#watermarks
	EstimatedLowWatermark *timestamppb.Timestamp `` /* 127-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ReadChangeStreamResponse_DataChange_ struct {
	// A mutation to the partition.
	DataChange *ReadChangeStreamResponse_DataChange `protobuf:"bytes,1,opt,name=data_change,json=dataChange,proto3,oneof"`
}

type ReadChangeStreamResponse_DataChange_Type int32

type ReadChangeStreamResponse_Heartbeat struct {

	// A token that can be provided to a subsequent `ReadChangeStream` call
	// to pick up reading at the current stream position.
	ContinuationToken *StreamContinuationToken `protobuf:"bytes,1,opt,name=continuation_token,json=continuationToken,proto3" json:"continuation_token,omitempty"`
	// An estimate of the commit timestamp that is usually lower than or equal
	// to any timestamp for a record that will be delivered in the future on the
	// stream. It is possible that, under particular circumstances that a future
	// record has a timestamp is is lower than a previously seen timestamp. For
	// an example usage see
	// https://beam.apache.org/documentation/basics/#watermarks
	EstimatedLowWatermark *timestamppb.Timestamp `` /* 126-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ReadChangeStreamResponse_Heartbeat_ struct {
	// A periodic heartbeat message.
	Heartbeat *ReadChangeStreamResponse_Heartbeat `protobuf:"bytes,2,opt,name=heartbeat,proto3,oneof"`
}

type ReadChangeStreamResponse_MutationChunk struct {

	// If set, then the mutation is a `SetCell` with a chunked value across
	// multiple messages.
	ChunkInfo *ReadChangeStreamResponse_MutationChunk_ChunkInfo `protobuf:"bytes,1,opt,name=chunk_info,json=chunkInfo,proto3" json:"chunk_info,omitempty"`
	// If this is a continuation of a chunked message (`chunked_value_offset` >
	// 0), ignore all fields except the `SetCell`'s value and merge it with
	// the previous message by concatenating the value fields.
	Mutation *Mutation `protobuf:"bytes,2,opt,name=mutation,proto3" json:"mutation,omitempty"`
	// contains filtered or unexported fields
}

type ReadChangeStreamResponse_MutationChunk_ChunkInfo struct {

	// The total value size of all the chunks that make up the `SetCell`.
	ChunkedValueSize int32 `protobuf:"varint,1,opt,name=chunked_value_size,json=chunkedValueSize,proto3" json:"chunked_value_size,omitempty"`
	// The byte offset of this chunk into the total value size of the
	// mutation.
	ChunkedValueOffset int32 `protobuf:"varint,2,opt,name=chunked_value_offset,json=chunkedValueOffset,proto3" json:"chunked_value_offset,omitempty"`
	// When true, this is the last chunk of a chunked `SetCell`.
	LastChunk bool `protobuf:"varint,3,opt,name=last_chunk,json=lastChunk,proto3" json:"last_chunk,omitempty"`
	// contains filtered or unexported fields
}

type ReadIterationStats struct {

	// The rows seen (scanned) as part of the request. This includes the count of
	// rows returned, as captured below.
	RowsSeenCount int64 `protobuf:"varint,1,opt,name=rows_seen_count,json=rowsSeenCount,proto3" json:"rows_seen_count,omitempty"`
	// The rows returned as part of the request.
	RowsReturnedCount int64 `protobuf:"varint,2,opt,name=rows_returned_count,json=rowsReturnedCount,proto3" json:"rows_returned_count,omitempty"`
	// The cells seen (scanned) as part of the request. This includes the count of
	// cells returned, as captured below.
	CellsSeenCount int64 `protobuf:"varint,3,opt,name=cells_seen_count,json=cellsSeenCount,proto3" json:"cells_seen_count,omitempty"`
	// The cells returned as part of the request.
	CellsReturnedCount int64 `protobuf:"varint,4,opt,name=cells_returned_count,json=cellsReturnedCount,proto3" json:"cells_returned_count,omitempty"`
	// contains filtered or unexported fields
}

type ReadModifyWriteRowRequest struct {

	// Optional. The unique name of the table to which the read/modify/write rules
	// should be applied.
	//
	// Values are of the form
	// `projects/<project>/instances/<instance>/tables/<table>`.
	TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
	// Optional. The unique name of the AuthorizedView to which the
	// read/modify/write rules should be applied.
	//
	// Values are of the form
	// `projects/<project>/instances/<instance>/tables/<table>/authorizedViews/<authorized_view>`.
	AuthorizedViewName string `protobuf:"bytes,6,opt,name=authorized_view_name,json=authorizedViewName,proto3" json:"authorized_view_name,omitempty"`
	// This value specifies routing for replication. If not specified, the
	// "default" application profile will be used.
	AppProfileId string `protobuf:"bytes,4,opt,name=app_profile_id,json=appProfileId,proto3" json:"app_profile_id,omitempty"`
	// Required. The key of the row to which the read/modify/write rules should be
	// applied.
	RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
	// Required. Rules specifying how the specified row's contents are to be
	// transformed into writes. Entries are applied in order, meaning that earlier
	// rules will affect the results of later ones.
	Rules []*ReadModifyWriteRule `protobuf:"bytes,3,rep,name=rules,proto3" json:"rules,omitempty"`
	// contains filtered or unexported fields
}

type ReadModifyWriteRowResponse struct {

	// A Row containing the new contents of all cells modified by the request.
	Row *Row `protobuf:"bytes,1,opt,name=row,proto3" json:"row,omitempty"`
	// contains filtered or unexported fields
}

type ReadModifyWriteRule struct {

	// The name of the family to which the read/modify/write should be applied.
	// Must match `[-_.a-zA-Z0-9]+`
	FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
	// The qualifier of the column to which the read/modify/write should be
	// applied.
	// Can be any byte string, including the empty string.
	ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
	// The rule used to determine the column's new latest value from its current
	// latest value.
	//
	// Types that are assignable to Rule:
	//
	//	*ReadModifyWriteRule_AppendValue
	//	*ReadModifyWriteRule_IncrementAmount
	Rule isReadModifyWriteRule_Rule `protobuf_oneof:"rule"`
	// contains filtered or unexported fields
}

type ReadModifyWriteRule_AppendValue struct {
	// Rule specifying that `append_value` be appended to the existing value.
	// If the targeted cell is unset, it will be treated as containing the
	// empty string.
	AppendValue []byte `protobuf:"bytes,3,opt,name=append_value,json=appendValue,proto3,oneof"`
}

type ReadModifyWriteRule_IncrementAmount struct {
	// Rule specifying that `increment_amount` be added to the existing value.
	// If the targeted cell is unset, it will be treated as containing a zero.
	// Otherwise, the targeted cell must contain an 8-byte value (interpreted
	// as a 64-bit big-endian signed integer), or the entire request will fail.
	IncrementAmount int64 `protobuf:"varint,4,opt,name=increment_amount,json=incrementAmount,proto3,oneof"`
}

type ReadRowsRequest struct {

	// Optional. The unique name of the table from which to read.
	//
	// Values are of the form
	// `projects/<project>/instances/<instance>/tables/<table>`.
	TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
	// Optional. The unique name of the AuthorizedView from which to read.
	//
	// Values are of the form
	// `projects/<project>/instances/<instance>/tables/<table>/authorizedViews/<authorized_view>`.
	AuthorizedViewName string `protobuf:"bytes,9,opt,name=authorized_view_name,json=authorizedViewName,proto3" json:"authorized_view_name,omitempty"`
	// This value specifies routing for replication. If not specified, the
	// "default" application profile will be used.
	AppProfileId string `protobuf:"bytes,5,opt,name=app_profile_id,json=appProfileId,proto3" json:"app_profile_id,omitempty"`
	// The row keys and/or ranges to read sequentially. If not specified, reads
	// from all rows.
	Rows *RowSet `protobuf:"bytes,2,opt,name=rows,proto3" json:"rows,omitempty"`
	// The filter to apply to the contents of the specified row(s). If unset,
	// reads the entirety of each row.
	Filter *RowFilter `protobuf:"bytes,3,opt,name=filter,proto3" json:"filter,omitempty"`
	// The read will stop after committing to N rows' worth of results. The
	// default (zero) is to return all results.
	RowsLimit int64 `protobuf:"varint,4,opt,name=rows_limit,json=rowsLimit,proto3" json:"rows_limit,omitempty"`
	// The view into RequestStats, as described above.
	RequestStatsView ReadRowsRequest_RequestStatsView `` /* 169-byte string literal not displayed */
	// Experimental API - Please note that this API is currently experimental
	// and can change in the future.
	//
	// Return rows in lexiographical descending order of the row keys. The row
	// contents will not be affected by this flag.
	//
	// Example result set:
	//
	//	[
	//	  {key: "k2", "f:col1": "v1", "f:col2": "v1"},
	//	  {key: "k1", "f:col1": "v2", "f:col2": "v2"}
	//	]
	Reversed bool `protobuf:"varint,7,opt,name=reversed,proto3" json:"reversed,omitempty"`
	// contains filtered or unexported fields
}

type ReadRowsRequest_RequestStatsView int32

type ReadRowsResponse struct {

	// A collection of a row's contents as part of the read request.
	Chunks []*ReadRowsResponse_CellChunk `protobuf:"bytes,1,rep,name=chunks,proto3" json:"chunks,omitempty"`
	// Optionally the server might return the row key of the last row it
	// has scanned.  The client can use this to construct a more
	// efficient retry request if needed: any row keys or portions of
	// ranges less than this row key can be dropped from the request.
	// This is primarily useful for cases where the server has read a
	// lot of data that was filtered out since the last committed row
	// key, allowing the client to skip that work on a retry.
	LastScannedRowKey []byte `protobuf:"bytes,2,opt,name=last_scanned_row_key,json=lastScannedRowKey,proto3" json:"last_scanned_row_key,omitempty"`
	// If requested, provide enhanced query performance statistics. The semantics
	// dictate:
	//   - request_stats is empty on every (streamed) response, except
	//   - request_stats has non-empty information after all chunks have been
	//     streamed, where the ReadRowsResponse message only contains
	//     request_stats.
	//   - For example, if a read request would have returned an empty
	//     response instead a single ReadRowsResponse is streamed with empty
	//     chunks and request_stats filled.
	//
	// Visually, response messages will stream as follows:
	//
	//	 ... -> {chunks: [...]} -> {chunks: [], request_stats: {...}}
	//	\______________________/  \________________________________/
	//	    Primary response         Trailer of RequestStats info
	//
	// Or if the read did not return any values:
	//
	//	{chunks: [], request_stats: {...}}
	//	\________________________________/
	//	   Trailer of RequestStats info
	RequestStats *RequestStats `protobuf:"bytes,3,opt,name=request_stats,json=requestStats,proto3" json:"request_stats,omitempty"`
	// contains filtered or unexported fields
}

type ReadRowsResponse_CellChunk struct {

	// The row key for this chunk of data.  If the row key is empty,
	// this CellChunk is a continuation of the same row as the previous
	// CellChunk in the response stream, even if that CellChunk was in a
	// previous ReadRowsResponse message.
	RowKey []byte `protobuf:"bytes,1,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
	// The column family name for this chunk of data.  If this message
	// is not present this CellChunk is a continuation of the same column
	// family as the previous CellChunk.  The empty string can occur as a
	// column family name in a response so clients must check
	// explicitly for the presence of this message, not just for
	// `family_name.value` being non-empty.
	FamilyName *wrapperspb.StringValue `protobuf:"bytes,2,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
	// The column qualifier for this chunk of data.  If this message
	// is not present, this CellChunk is a continuation of the same column
	// as the previous CellChunk.  Column qualifiers may be empty so
	// clients must check for the presence of this message, not just
	// for `qualifier.value` being non-empty.
	Qualifier *wrapperspb.BytesValue `protobuf:"bytes,3,opt,name=qualifier,proto3" json:"qualifier,omitempty"`
	// The cell's stored timestamp, which also uniquely identifies it
	// within its column.  Values are always expressed in
	// microseconds, but individual tables may set a coarser
	// granularity to further restrict the allowed values. For
	// example, a table which specifies millisecond granularity will
	// only allow values of `timestamp_micros` which are multiples of
	// 1000.  Timestamps are only set in the first CellChunk per cell
	// (for cells split into multiple chunks).
	TimestampMicros int64 `protobuf:"varint,4,opt,name=timestamp_micros,json=timestampMicros,proto3" json:"timestamp_micros,omitempty"`
	// Labels applied to the cell by a
	// [RowFilter][google.bigtable.v2.RowFilter].  Labels are only set
	// on the first CellChunk per cell.
	Labels []string `protobuf:"bytes,5,rep,name=labels,proto3" json:"labels,omitempty"`
	// The value stored in the cell.  Cell values can be split across
	// multiple CellChunks.  In that case only the value field will be
	// set in CellChunks after the first: the timestamp and labels
	// will only be present in the first CellChunk, even if the first
	// CellChunk came in a previous ReadRowsResponse.
	Value []byte `protobuf:"bytes,6,opt,name=value,proto3" json:"value,omitempty"`
	// If this CellChunk is part of a chunked cell value and this is
	// not the final chunk of that cell, value_size will be set to the
	// total length of the cell value.  The client can use this size
	// to pre-allocate memory to hold the full cell value.
	ValueSize int32 `protobuf:"varint,7,opt,name=value_size,json=valueSize,proto3" json:"value_size,omitempty"`
	// Signals to the client concerning previous CellChunks received.
	//
	// Types that are assignable to RowStatus:
	//
	//	*ReadRowsResponse_CellChunk_ResetRow
	//	*ReadRowsResponse_CellChunk_CommitRow
	RowStatus isReadRowsResponse_CellChunk_RowStatus `protobuf_oneof:"row_status"`
	// contains filtered or unexported fields
}

type ReadRowsResponse_CellChunk_CommitRow struct {
	// Indicates that the client can safely process all previous chunks for
	// `row_key`, as its data has been fully read.
	CommitRow bool `protobuf:"varint,9,opt,name=commit_row,json=commitRow,proto3,oneof"`
}

type ReadRowsResponse_CellChunk_ResetRow struct {
	// Indicates that the client should drop all previous chunks for
	// `row_key`, as it will be re-read from the beginning.
	ResetRow bool `protobuf:"varint,8,opt,name=reset_row,json=resetRow,proto3,oneof"`
}

type RequestLatencyStats struct {

	// The latency measured by the frontend server handling this request, from
	// when the request was received, to when this value is sent back in the
	// response. For more context on the component that is measuring this latency,
	// see: https://cloud.google.com/bigtable/docs/overview
	//
	// Note: This value may be slightly shorter than the value reported into
	// aggregate latency metrics in Monitoring for this request
	// (https://cloud.google.com/bigtable/docs/monitoring-instance) as this value
	// needs to be sent in the response before the latency measurement including
	// that transmission is finalized.
	//
	// Note: This value includes the end-to-end latency of contacting nodes in
	// the targeted cluster, e.g. measuring from when the first byte arrives at
	// the frontend server, to when this value is sent back as the last value in
	// the response, including any latency incurred by contacting nodes, waiting
	// for results from nodes, and finally sending results from nodes back to the
	// caller.
	FrontendServerLatency *durationpb.Duration `` /* 126-byte string literal not displayed */
	// contains filtered or unexported fields
}

type RequestStats struct {

	// Information pertaining to each request type received. The type is chosen
	// based on the requested view.
	//
	// See the messages above for additional context.
	//
	// Types that are assignable to StatsView:
	//
	//	*RequestStats_FullReadStatsView
	StatsView isRequestStats_StatsView `protobuf_oneof:"stats_view"`
	// contains filtered or unexported fields
}

type RequestStats_FullReadStatsView struct {
	// Available with the ReadRowsRequest.RequestStatsView.REQUEST_STATS_FULL
	// view, see package google.bigtable.v2.
	FullReadStatsView *FullReadStatsView `protobuf:"bytes,1,opt,name=full_read_stats_view,json=fullReadStatsView,proto3,oneof"`
}

type ResponseParams struct {

	// The cloud bigtable zone associated with the cluster.
	ZoneId *string `protobuf:"bytes,1,opt,name=zone_id,json=zoneId,proto3,oneof" json:"zone_id,omitempty"`
	// Identifier for a cluster that represents set of
	// bigtable resources.
	ClusterId *string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3,oneof" json:"cluster_id,omitempty"`
	// contains filtered or unexported fields
}

type Row struct {

	// The unique key which identifies this row within its table. This is the same
	// key that's used to identify the row in, for example, a MutateRowRequest.
	// May contain any non-empty byte string up to 4KiB in length.
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// May be empty, but only if the entire row is empty.
	// The mutual ordering of column families is not specified.
	Families []*Family `protobuf:"bytes,2,rep,name=families,proto3" json:"families,omitempty"`
	// contains filtered or unexported fields
}

type RowFilter struct {

	// Which of the possible RowFilter types to apply. If none are set, this
	// RowFilter returns all cells in the input row.
	//
	// Types that are assignable to Filter:
	//
	//	*RowFilter_Chain_
	//	*RowFilter_Interleave_
	//	*RowFilter_Condition_
	//	*RowFilter_Sink
	//	*RowFilter_PassAllFilter
	//	*RowFilter_BlockAllFilter
	//	*RowFilter_RowKeyRegexFilter
	//	*RowFilter_RowSampleFilter
	//	*RowFilter_FamilyNameRegexFilter
	//	*RowFilter_ColumnQualifierRegexFilter
	//	*RowFilter_ColumnRangeFilter
	//	*RowFilter_TimestampRangeFilter
	//	*RowFilter_ValueRegexFilter
	//	*RowFilter_ValueRangeFilter
	//	*RowFilter_CellsPerRowOffsetFilter
	//	*RowFilter_CellsPerRowLimitFilter
	//	*RowFilter_CellsPerColumnLimitFilter
	//	*RowFilter_StripValueTransformer
	//	*RowFilter_ApplyLabelTransformer
	Filter isRowFilter_Filter `protobuf_oneof:"filter"`
	// contains filtered or unexported fields
}

type RowFilter_ApplyLabelTransformer struct {
	// Applies the given label to all cells in the output row. This allows
	// the client to determine which results were produced from which part of
	// the filter.
	//
	// Values must be at most 15 characters in length, and match the RE2
	// pattern `[a-z0-9\\-]+`
	//
	// Due to a technical limitation, it is not currently possible to apply
	// multiple labels to a cell. As a result, a Chain may have no more than
	// one sub-filter which contains a `apply_label_transformer`. It is okay for
	// an Interleave to contain multiple `apply_label_transformers`, as they
	// will be applied to separate copies of the input. This may be relaxed in
	// the future.
	ApplyLabelTransformer string `protobuf:"bytes,19,opt,name=apply_label_transformer,json=applyLabelTransformer,proto3,oneof"`
}

type RowFilter_BlockAllFilter struct {
	// Does not match any cells, regardless of input. Useful for temporarily
	// disabling just part of a filter.
	BlockAllFilter bool `protobuf:"varint,18,opt,name=block_all_filter,json=blockAllFilter,proto3,oneof"`
}

type RowFilter_CellsPerColumnLimitFilter struct {
	// Matches only the most recent N cells within each column. For example,
	// if N=2, this filter would match column `foo:bar` at timestamps 10 and 9,
	// skip all earlier cells in `foo:bar`, and then begin matching again in
	// column `foo:bar2`.
	// If duplicate cells are present, as is possible when using an Interleave,
	// each copy of the cell is counted separately.
	CellsPerColumnLimitFilter int32 `protobuf:"varint,12,opt,name=cells_per_column_limit_filter,json=cellsPerColumnLimitFilter,proto3,oneof"`
}

type RowFilter_CellsPerRowLimitFilter struct {
	// Matches only the first N cells of each row.
	// If duplicate cells are present, as is possible when using an Interleave,
	// each copy of the cell is counted separately.
	CellsPerRowLimitFilter int32 `protobuf:"varint,11,opt,name=cells_per_row_limit_filter,json=cellsPerRowLimitFilter,proto3,oneof"`
}

type RowFilter_CellsPerRowOffsetFilter struct {
	// Skips the first N cells of each row, matching all subsequent cells.
	// If duplicate cells are present, as is possible when using an Interleave,
	// each copy of the cell is counted separately.
	CellsPerRowOffsetFilter int32 `protobuf:"varint,10,opt,name=cells_per_row_offset_filter,json=cellsPerRowOffsetFilter,proto3,oneof"`
}

type RowFilter_Chain struct {

	// The elements of "filters" are chained together to process the input row:
	// in row -> f(0) -> intermediate row -> f(1) -> ... -> f(N) -> out row
	// The full chain is executed atomically.
	Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
	// contains filtered or unexported fields
}

type RowFilter_Chain_ struct {
	// Applies several RowFilters to the data in sequence, progressively
	// narrowing the results.
	Chain *RowFilter_Chain `protobuf:"bytes,1,opt,name=chain,proto3,oneof"`
}

type RowFilter_ColumnQualifierRegexFilter struct {
	// Matches only cells from columns whose qualifiers satisfy the given RE2
	// regex.
	// Note that, since column qualifiers can contain arbitrary bytes, the `\C`
	// escape sequence must be used if a true wildcard is desired. The `.`
	// character will not match the new line character `\n`, which may be
	// present in a binary qualifier.
	ColumnQualifierRegexFilter []byte `protobuf:"bytes,6,opt,name=column_qualifier_regex_filter,json=columnQualifierRegexFilter,proto3,oneof"`
}

type RowFilter_ColumnRangeFilter struct {
	// Matches only cells from columns within the given range.
	ColumnRangeFilter *ColumnRange `protobuf:"bytes,7,opt,name=column_range_filter,json=columnRangeFilter,proto3,oneof"`
}

type RowFilter_Condition struct {

	// If `predicate_filter` outputs any cells, then `true_filter` will be
	// evaluated on the input row. Otherwise, `false_filter` will be evaluated.
	PredicateFilter *RowFilter `protobuf:"bytes,1,opt,name=predicate_filter,json=predicateFilter,proto3" json:"predicate_filter,omitempty"`
	// The filter to apply to the input row if `predicate_filter` returns any
	// results. If not provided, no results will be returned in the true case.
	TrueFilter *RowFilter `protobuf:"bytes,2,opt,name=true_filter,json=trueFilter,proto3" json:"true_filter,omitempty"`
	// The filter to apply to the input row if `predicate_filter` does not
	// return any results. If not provided, no results will be returned in the
	// false case.
	FalseFilter *RowFilter `protobuf:"bytes,3,opt,name=false_filter,json=falseFilter,proto3" json:"false_filter,omitempty"`
	// contains filtered or unexported fields
}

type RowFilter_Condition_ struct {
	// Applies one of two possible RowFilters to the data based on the output of
	// a predicate RowFilter.
	Condition *RowFilter_Condition `protobuf:"bytes,3,opt,name=condition,proto3,oneof"`
}

type RowFilter_FamilyNameRegexFilter struct {
	// Matches only cells from columns whose families satisfy the given RE2
	// regex. For technical reasons, the regex must not contain the `:`
	// character, even if it is not being used as a literal.
	// Note that, since column families cannot contain the new line character
	// `\n`, it is sufficient to use `.` as a full wildcard when matching
	// column family names.
	FamilyNameRegexFilter string `protobuf:"bytes,5,opt,name=family_name_regex_filter,json=familyNameRegexFilter,proto3,oneof"`
}

type RowFilter_Interleave struct {

	// The elements of "filters" all process a copy of the input row, and the
	// results are pooled, sorted, and combined into a single output row.
	// If multiple cells are produced with the same column and timestamp,
	// they will all appear in the output row in an unspecified mutual order.
	// Consider the following example, with three filters:
	//
	//	                             input row
	//	                                 |
	//	       -----------------------------------------------------
	//	       |                         |                         |
	//	      f(0)                      f(1)                      f(2)
	//	       |                         |                         |
	//	1: foo,bar,10,x             foo,bar,10,z              far,bar,7,a
	//	2: foo,blah,11,z            far,blah,5,x              far,blah,5,x
	//	       |                         |                         |
	//	       -----------------------------------------------------
	//	                                 |
	//	1:                      foo,bar,10,z   // could have switched with #2
	//	2:                      foo,bar,10,x   // could have switched with #1
	//	3:                      foo,blah,11,z
	//	4:                      far,bar,7,a
	//	5:                      far,blah,5,x   // identical to #6
	//	6:                      far,blah,5,x   // identical to #5
	//
	// All interleaved filters are executed atomically.
	Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
	// contains filtered or unexported fields
}