google-cloud-bigtable-v2 0.1.0

data/proto_docs/google/bigtable/v2/bigtable.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Auto-generated by gapic-generator-ruby. DO NOT EDIT!
+
+
+module Google
+  module Cloud
+    module Bigtable
+      module V2
+        # Request message for Bigtable.ReadRows.
+        # @!attribute [rw] table_name
+        #   @return [::String]
+        #     Required. The unique name of the table from which to read.
+        #     Values are of the form
+        #     `projects/<project>/instances/<instance>/tables/<table>`.
+        # @!attribute [rw] app_profile_id
+        #   @return [::String]
+        #     This value specifies routing for replication. If not specified, the
+        #     "default" application profile will be used.
+        # @!attribute [rw] rows
+        #   @return [::Google::Cloud::Bigtable::V2::RowSet]
+        #     The row keys and/or ranges to read. If not specified, reads from all rows.
+        # @!attribute [rw] filter
+        #   @return [::Google::Cloud::Bigtable::V2::RowFilter]
+        #     The filter to apply to the contents of the specified row(s). If unset,
+        #     reads the entirety of each row.
+        # @!attribute [rw] rows_limit
+        #   @return [::Integer]
+        #     The read will terminate after committing to N rows' worth of results. The
+        #     default (zero) is to return all results.
+        class ReadRowsRequest
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Response message for Bigtable.ReadRows.
+        # @!attribute [rw] chunks
+        #   @return [::Array<::Google::Cloud::Bigtable::V2::ReadRowsResponse::CellChunk>]
+        #     A collection of a row's contents as part of the read request.
+        # @!attribute [rw] last_scanned_row_key
+        #   @return [::String]
+        #     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.
+        class ReadRowsResponse
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+
+          # Specifies a piece of a row's contents returned as part of the read
+          # response stream.
+          # @!attribute [rw] row_key
+          #   @return [::String]
+          #     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.
+          # @!attribute [rw] family_name
+          #   @return [::Google::Protobuf::StringValue]
+          #     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.
+          # @!attribute [rw] qualifier
+          #   @return [::Google::Protobuf::BytesValue]
+          #     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.
+          # @!attribute [rw] timestamp_micros
+          #   @return [::Integer]
+          #     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).
+          # @!attribute [rw] labels
+          #   @return [::Array<::String>]
+          #     Labels applied to the cell by a
+          #     {::Google::Cloud::Bigtable::V2::RowFilter RowFilter}.  Labels are only set
+          #     on the first CellChunk per cell.
+          # @!attribute [rw] value
+          #   @return [::String]
+          #     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.
+          # @!attribute [rw] value_size
+          #   @return [::Integer]
+          #     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.
+          # @!attribute [rw] reset_row
+          #   @return [::Boolean]
+          #     Indicates that the client should drop all previous chunks for
+          #     `row_key`, as it will be re-read from the beginning.
+          # @!attribute [rw] commit_row
+          #   @return [::Boolean]
+          #     Indicates that the client can safely process all previous chunks for
+          #     `row_key`, as its data has been fully read.
+          class CellChunk
+            include ::Google::Protobuf::MessageExts
+            extend ::Google::Protobuf::MessageExts::ClassMethods
+          end
+        end
+
+        # Request message for Bigtable.SampleRowKeys.
+        # @!attribute [rw] table_name
+        #   @return [::String]
+        #     Required. The unique name of the table from which to sample row keys.
+        #     Values are of the form
+        #     `projects/<project>/instances/<instance>/tables/<table>`.
+        # @!attribute [rw] app_profile_id
+        #   @return [::String]
+        #     This value specifies routing for replication. If not specified, the
+        #     "default" application profile will be used.
+        class SampleRowKeysRequest
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Response message for Bigtable.SampleRowKeys.
+        # @!attribute [rw] row_key
+        #   @return [::String]
+        #     Sorted streamed sequence of sample row keys in the table. The table might
+        #     have contents before the first row key in the list and after the last one,
+        #     but a key containing the empty string indicates "end of table" and will be
+        #     the last response given, if present.
+        #     Note that row keys in this list may not have ever been written to or read
+        #     from, and users should therefore not make any assumptions about the row key
+        #     structure that are specific to their use case.
+        # @!attribute [rw] offset_bytes
+        #   @return [::Integer]
+        #     Approximate total storage space used by all rows in the table which precede
+        #     `row_key`. Buffering the contents of all rows between two subsequent
+        #     samples would require space roughly equal to the difference in their
+        #     `offset_bytes` fields.
+        class SampleRowKeysResponse
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Request message for Bigtable.MutateRow.
+        # @!attribute [rw] table_name
+        #   @return [::String]
+        #     Required. The unique name of the table to which the mutation should be applied.
+        #     Values are of the form
+        #     `projects/<project>/instances/<instance>/tables/<table>`.
+        # @!attribute [rw] app_profile_id
+        #   @return [::String]
+        #     This value specifies routing for replication. If not specified, the
+        #     "default" application profile will be used.
+        # @!attribute [rw] row_key
+        #   @return [::String]
+        #     Required. The key of the row to which the mutation should be applied.
+        # @!attribute [rw] mutations
+        #   @return [::Array<::Google::Cloud::Bigtable::V2::Mutation>]
+        #     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.
+        class MutateRowRequest
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Response message for Bigtable.MutateRow.
+        class MutateRowResponse
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Request message for BigtableService.MutateRows.
+        # @!attribute [rw] table_name
+        #   @return [::String]
+        #     Required. The unique name of the table to which the mutations should be applied.
+        # @!attribute [rw] app_profile_id
+        #   @return [::String]
+        #     This value specifies routing for replication. If not specified, the
+        #     "default" application profile will be used.
+        # @!attribute [rw] entries
+        #   @return [::Array<::Google::Cloud::Bigtable::V2::MutateRowsRequest::Entry>]
+        #     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.
+        class MutateRowsRequest
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+
+          # A mutation for a given row.
+          # @!attribute [rw] row_key
+          #   @return [::String]
+          #     The key of the row to which the `mutations` should be applied.
+          # @!attribute [rw] mutations
+          #   @return [::Array<::Google::Cloud::Bigtable::V2::Mutation>]
+          #     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.
+          class Entry
+            include ::Google::Protobuf::MessageExts
+            extend ::Google::Protobuf::MessageExts::ClassMethods
+          end
+        end
+
+        # Response message for BigtableService.MutateRows.
+        # @!attribute [rw] entries
+        #   @return [::Array<::Google::Cloud::Bigtable::V2::MutateRowsResponse::Entry>]
+        #     One or more results for Entries from the batch request.
+        class MutateRowsResponse
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+
+          # The result of applying a passed mutation in the original request.
+          # @!attribute [rw] index
+          #   @return [::Integer]
+          #     The index into the original request's `entries` list of the Entry
+          #     for which a result is being reported.
+          # @!attribute [rw] status
+          #   @return [::Google::Rpc::Status]
+          #     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.
+          class Entry
+            include ::Google::Protobuf::MessageExts
+            extend ::Google::Protobuf::MessageExts::ClassMethods
+          end
+        end
+
+        # Request message for Bigtable.CheckAndMutateRow.
+        # @!attribute [rw] table_name
+        #   @return [::String]
+        #     Required. 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>`.
+        # @!attribute [rw] app_profile_id
+        #   @return [::String]
+        #     This value specifies routing for replication. If not specified, the
+        #     "default" application profile will be used.
+        # @!attribute [rw] row_key
+        #   @return [::String]
+        #     Required. The key of the row to which the conditional mutation should be applied.
+        # @!attribute [rw] predicate_filter
+        #   @return [::Google::Cloud::Bigtable::V2::RowFilter]
+        #     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.
+        # @!attribute [rw] true_mutations
+        #   @return [::Array<::Google::Cloud::Bigtable::V2::Mutation>]
+        #     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.
+        # @!attribute [rw] false_mutations
+        #   @return [::Array<::Google::Cloud::Bigtable::V2::Mutation>]
+        #     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.
+        class CheckAndMutateRowRequest
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Response message for Bigtable.CheckAndMutateRow.
+        # @!attribute [rw] predicate_matched
+        #   @return [::Boolean]
+        #     Whether or not the request's `predicate_filter` yielded any results for
+        #     the specified row.
+        class CheckAndMutateRowResponse
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Request message for Bigtable.ReadModifyWriteRow.
+        # @!attribute [rw] table_name
+        #   @return [::String]
+        #     Required. 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>`.
+        # @!attribute [rw] app_profile_id
+        #   @return [::String]
+        #     This value specifies routing for replication. If not specified, the
+        #     "default" application profile will be used.
+        # @!attribute [rw] row_key
+        #   @return [::String]
+        #     Required. The key of the row to which the read/modify/write rules should be applied.
+        # @!attribute [rw] rules
+        #   @return [::Array<::Google::Cloud::Bigtable::V2::ReadModifyWriteRule>]
+        #     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.
+        class ReadModifyWriteRowRequest
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Response message for Bigtable.ReadModifyWriteRow.
+        # @!attribute [rw] row
+        #   @return [::Google::Cloud::Bigtable::V2::Row]
+        #     A Row containing the new contents of all cells modified by the request.
+        class ReadModifyWriteRowResponse
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+      end
+    end
+  end
+end

data/proto_docs/google/bigtable/v2/data.rb

@@ -0,0 +1,556 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Auto-generated by gapic-generator-ruby. DO NOT EDIT!
+
+
+module Google
+  module Cloud
+    module Bigtable
+      module V2
+        # Specifies the complete (requested) contents of a single row of a table.
+        # Rows which exceed 256MiB in size cannot be read in full.
+        # @!attribute [rw] key
+        #   @return [::String]
+        #     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.
+        # @!attribute [rw] families
+        #   @return [::Array<::Google::Cloud::Bigtable::V2::Family>]
+        #     May be empty, but only if the entire row is empty.
+        #     The mutual ordering of column families is not specified.
+        class Row
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Specifies (some of) the contents of a single row/column family intersection
+        # of a table.
+        # @!attribute [rw] name
+        #   @return [::String]
+        #     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.
+        # @!attribute [rw] columns
+        #   @return [::Array<::Google::Cloud::Bigtable::V2::Column>]
+        #     Must not be empty. Sorted in order of increasing "qualifier".
+        class Family
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Specifies (some of) the contents of a single row/column intersection of a
+        # table.
+        # @!attribute [rw] qualifier
+        #   @return [::String]
+        #     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.
+        # @!attribute [rw] cells
+        #   @return [::Array<::Google::Cloud::Bigtable::V2::Cell>]
+        #     Must not be empty. Sorted in order of decreasing "timestamp_micros".
+        class Column
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Specifies (some of) the contents of a single row/column/timestamp of a table.
+        # @!attribute [rw] timestamp_micros
+        #   @return [::Integer]
+        #     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.
+        # @!attribute [rw] value
+        #   @return [::String]
+        #     The value stored in the cell.
+        #     May contain any byte string, including the empty string, up to 100MiB in
+        #     length.
+        # @!attribute [rw] labels
+        #   @return [::Array<::String>]
+        #     Labels applied to the cell by a {::Google::Cloud::Bigtable::V2::RowFilter RowFilter}.
+        class Cell
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Specifies a contiguous range of rows.
+        # @!attribute [rw] start_key_closed
+        #   @return [::String]
+        #     Used when giving an inclusive lower bound for the range.
+        # @!attribute [rw] start_key_open
+        #   @return [::String]
+        #     Used when giving an exclusive lower bound for the range.
+        # @!attribute [rw] end_key_open
+        #   @return [::String]
+        #     Used when giving an exclusive upper bound for the range.
+        # @!attribute [rw] end_key_closed
+        #   @return [::String]
+        #     Used when giving an inclusive upper bound for the range.
+        class RowRange
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Specifies a non-contiguous set of rows.
+        # @!attribute [rw] row_keys
+        #   @return [::Array<::String>]
+        #     Single rows included in the set.
+        # @!attribute [rw] row_ranges
+        #   @return [::Array<::Google::Cloud::Bigtable::V2::RowRange>]
+        #     Contiguous row ranges included in the set.
+        class RowSet
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Specifies a contiguous range of columns within a single column family.
+        # The range spans from &lt;column_family&gt;:&lt;start_qualifier&gt; to
+        # &lt;column_family&gt;:&lt;end_qualifier&gt;, where both bounds can be either
+        # inclusive or exclusive.
+        # @!attribute [rw] family_name
+        #   @return [::String]
+        #     The name of the column family within which this range falls.
+        # @!attribute [rw] start_qualifier_closed
+        #   @return [::String]
+        #     Used when giving an inclusive lower bound for the range.
+        # @!attribute [rw] start_qualifier_open
+        #   @return [::String]
+        #     Used when giving an exclusive lower bound for the range.
+        # @!attribute [rw] end_qualifier_closed
+        #   @return [::String]
+        #     Used when giving an inclusive upper bound for the range.
+        # @!attribute [rw] end_qualifier_open
+        #   @return [::String]
+        #     Used when giving an exclusive upper bound for the range.
+        class ColumnRange
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Specified a contiguous range of microsecond timestamps.
+        # @!attribute [rw] start_timestamp_micros
+        #   @return [::Integer]
+        #     Inclusive lower bound. If left empty, interpreted as 0.
+        # @!attribute [rw] end_timestamp_micros
+        #   @return [::Integer]
+        #     Exclusive upper bound. If left empty, interpreted as infinity.
+        class TimestampRange
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Specifies a contiguous range of raw byte values.
+        # @!attribute [rw] start_value_closed
+        #   @return [::String]
+        #     Used when giving an inclusive lower bound for the range.
+        # @!attribute [rw] start_value_open
+        #   @return [::String]
+        #     Used when giving an exclusive lower bound for the range.
+        # @!attribute [rw] end_value_closed
+        #   @return [::String]
+        #     Used when giving an inclusive upper bound for the range.
+        # @!attribute [rw] end_value_open
+        #   @return [::String]
+        #     Used when giving an exclusive upper bound for the range.
+        class ValueRange
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+
+        # Takes a row as input and produces an alternate view of the row based on
+        # specified rules. For example, a RowFilter might trim down a row to include
+        # just the cells from columns matching a given regular expression, or might
+        # return all the cells of a row but not their values. More complicated filters
+        # can be composed out of these components to express requests such as, "within
+        # every column of a particular family, give just the two most recent cells
+        # which are older than timestamp X."
+        #
+        # There are two broad categories of RowFilters (true filters and transformers),
+        # as well as two ways to compose simple filters into more complex ones
+        # (chains and interleaves). They work as follows:
+        #
+        # * True filters alter the input row by excluding some of its cells wholesale
+        # from the output row. An example of a true filter is the `value_regex_filter`,
+        # which excludes cells whose values don't match the specified pattern. All
+        # regex true filters use RE2 syntax (https://github.com/google/re2/wiki/Syntax)
+        # in raw byte mode (RE2::Latin1), and are evaluated as full matches. An
+        # important point to keep in mind is that `RE2(.)` is equivalent by default to
+        # `RE2([^\n])`, meaning that it does not match newlines. When attempting to
+        # match an arbitrary byte, you should therefore use the escape sequence `\C`,
+        # which may need to be further escaped as `\\C` in your client language.
+        #
+        # * Transformers alter the input row by changing the values of some of its
+        # cells in the output, without excluding them completely. Currently, the only
+        # supported transformer is the `strip_value_transformer`, which replaces every
+        # cell's value with the empty string.
+        #
+        # * Chains and interleaves are described in more detail in the
+        # RowFilter.Chain and RowFilter.Interleave documentation.
+        #
+        # The total serialized size of a RowFilter message must not
+        # exceed 4096 bytes, and RowFilters may not be nested within each other
+        # (in Chains or Interleaves) to a depth of more than 20.
+        # @!attribute [rw] chain
+        #   @return [::Google::Cloud::Bigtable::V2::RowFilter::Chain]
+        #     Applies several RowFilters to the data in sequence, progressively
+        #     narrowing the results.
+        # @!attribute [rw] interleave
+        #   @return [::Google::Cloud::Bigtable::V2::RowFilter::Interleave]
+        #     Applies several RowFilters to the data in parallel and combines the
+        #     results.
+        # @!attribute [rw] condition
+        #   @return [::Google::Cloud::Bigtable::V2::RowFilter::Condition]
+        #     Applies one of two possible RowFilters to the data based on the output of
+        #     a predicate RowFilter.
+        # @!attribute [rw] sink
+        #   @return [::Boolean]
+        #     ADVANCED USE ONLY.
+        #     Hook for introspection into the RowFilter. Outputs all cells directly to
+        #     the output of the read rather than to any parent filter. Consider the
+        #     following example:
+        #
+        #         Chain(
+        #           FamilyRegex("A"),
+        #           Interleave(
+        #             All(),
+        #             Chain(Label("foo"), Sink())
+        #           ),
+        #           QualifierRegex("B")
+        #         )
+        #
+        #                             A,A,1,w
+        #                             A,B,2,x
+        #                             B,B,4,z
+        #                                |
+        #                         FamilyRegex("A")
+        #                                |
+        #                             A,A,1,w
+        #                             A,B,2,x
+        #                                |
+        #                   +------------+-------------+
+        #                   |                          |
+        #                 All()                    Label(foo)
+        #                   |                          |
+        #                A,A,1,w              A,A,1,w,labels:[foo]
+        #                A,B,2,x              A,B,2,x,labels:[foo]
+        #                   |                          |
+        #                   |                        Sink() --------------+
+        #                   |                          |                  |
+        #                   +------------+      x------+          A,A,1,w,labels:[foo]
+        #                                |                        A,B,2,x,labels:[foo]
+        #                             A,A,1,w                             |
+        #                             A,B,2,x                             |
+        #                                |                                |
+        #                        QualifierRegex("B")                      |
+        #                                |                                |
+        #                             A,B,2,x                             |
+        #                                |                                |
+        #                                +--------------------------------+
+        #                                |
+        #                             A,A,1,w,labels:[foo]
+        #                             A,B,2,x,labels:[foo]  // could be switched
+        #                             A,B,2,x               // could be switched
+        #
+        #     Despite being excluded by the qualifier filter, a copy of every cell
+        #     that reaches the sink is present in the final result.
+        #
+        #     As with an {::Google::Cloud::Bigtable::V2::RowFilter::Interleave Interleave},
+        #     duplicate cells are possible, and appear in an unspecified mutual order.
+        #     In this case we have a duplicate with column "A:B" and timestamp 2,
+        #     because one copy passed through the all filter while the other was
+        #     passed through the label and sink. Note that one copy has label "foo",
+        #     while the other does not.
+        #
+        #     Cannot be used within the `predicate_filter`, `true_filter`, or
+        #     `false_filter` of a {::Google::Cloud::Bigtable::V2::RowFilter::Condition Condition}.
+        # @!attribute [rw] pass_all_filter
+        #   @return [::Boolean]
+        #     Matches all cells, regardless of input. Functionally equivalent to
+        #     leaving `filter` unset, but included for completeness.
+        # @!attribute [rw] block_all_filter
+        #   @return [::Boolean]
+        #     Does not match any cells, regardless of input. Useful for temporarily
+        #     disabling just part of a filter.
+        # @!attribute [rw] row_key_regex_filter
+        #   @return [::String]
+        #     Matches only cells from rows whose keys satisfy the given RE2 regex. In
+        #     other words, passes through the entire row when the key matches, and
+        #     otherwise produces an empty row.
+        #     Note that, since row keys 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 key.
+        # @!attribute [rw] row_sample_filter
+        #   @return [::Float]
+        #     Matches all cells from a row with probability p, and matches no cells
+        #     from the row with probability 1-p.
+        # @!attribute [rw] family_name_regex_filter
+        #   @return [::String]
+        #     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.
+        # @!attribute [rw] column_qualifier_regex_filter
+        #   @return [::String]
+        #     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.
+        # @!attribute [rw] column_range_filter
+        #   @return [::Google::Cloud::Bigtable::V2::ColumnRange]
+        #     Matches only cells from columns within the given range.
+        # @!attribute [rw] timestamp_range_filter
+        #   @return [::Google::Cloud::Bigtable::V2::TimestampRange]
+        #     Matches only cells with timestamps within the given range.
+        # @!attribute [rw] value_regex_filter
+        #   @return [::String]
+        #     Matches only cells with values that satisfy the given regular expression.
+        #     Note that, since cell values 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 value.
+        # @!attribute [rw] value_range_filter
+        #   @return [::Google::Cloud::Bigtable::V2::ValueRange]
+        #     Matches only cells with values that fall within the given range.
+        # @!attribute [rw] cells_per_row_offset_filter
+        #   @return [::Integer]
+        #     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.
+        # @!attribute [rw] cells_per_row_limit_filter
+        #   @return [::Integer]
+        #     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.
+        # @!attribute [rw] cells_per_column_limit_filter
+        #   @return [::Integer]
+        #     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.
+        # @!attribute [rw] strip_value_transformer
+        #   @return [::Boolean]
+        #     Replaces each cell's value with the empty string.
+        # @!attribute [rw] apply_label_transformer
+        #   @return [::String]
+        #     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.
+        class RowFilter
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+
+          # A RowFilter which sends rows through several RowFilters in sequence.
+          # @!attribute [rw] filters
+          #   @return [::Array<::Google::Cloud::Bigtable::V2::RowFilter>]
+          #     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.
+          class Chain
+            include ::Google::Protobuf::MessageExts
+            extend ::Google::Protobuf::MessageExts::ClassMethods
+          end
+
+          # A RowFilter which sends each row to each of several component
+          # RowFilters and interleaves the results.
+          # @!attribute [rw] filters
+          #   @return [::Array<::Google::Cloud::Bigtable::V2::RowFilter>]
+          #     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.
+          class Interleave
+            include ::Google::Protobuf::MessageExts
+            extend ::Google::Protobuf::MessageExts::ClassMethods
+          end
+
+          # A RowFilter which evaluates one of two possible RowFilters, depending on
+          # whether or not a predicate RowFilter outputs any cells from the input row.
+          #
+          # IMPORTANT NOTE: The predicate filter does not execute atomically with the
+          # true and false filters, which may lead to inconsistent or unexpected
+          # results. Additionally, Condition filters have poor performance, especially
+          # when filters are set for the false condition.
+          # @!attribute [rw] predicate_filter
+          #   @return [::Google::Cloud::Bigtable::V2::RowFilter]
+          #     If `predicate_filter` outputs any cells, then `true_filter` will be
+          #     evaluated on the input row. Otherwise, `false_filter` will be evaluated.
+          # @!attribute [rw] true_filter
+          #   @return [::Google::Cloud::Bigtable::V2::RowFilter]
+          #     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.
+          # @!attribute [rw] false_filter
+          #   @return [::Google::Cloud::Bigtable::V2::RowFilter]
+          #     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.
+          class Condition
+            include ::Google::Protobuf::MessageExts
+            extend ::Google::Protobuf::MessageExts::ClassMethods
+          end
+        end
+
+        # Specifies a particular change to be made to the contents of a row.
+        # @!attribute [rw] set_cell
+        #   @return [::Google::Cloud::Bigtable::V2::Mutation::SetCell]
+        #     Set a cell's value.
+        # @!attribute [rw] delete_from_column
+        #   @return [::Google::Cloud::Bigtable::V2::Mutation::DeleteFromColumn]
+        #     Deletes cells from a column.
+        # @!attribute [rw] delete_from_family
+        #   @return [::Google::Cloud::Bigtable::V2::Mutation::DeleteFromFamily]
+        #     Deletes cells from a column family.
+        # @!attribute [rw] delete_from_row
+        #   @return [::Google::Cloud::Bigtable::V2::Mutation::DeleteFromRow]
+        #     Deletes cells from the entire row.
+        class Mutation
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+
+          # A Mutation which sets the value of the specified cell.
+          # @!attribute [rw] family_name
+          #   @return [::String]
+          #     The name of the family into which new data should be written.
+          #     Must match `[-_.a-zA-Z0-9]+`
+          # @!attribute [rw] column_qualifier
+          #   @return [::String]
+          #     The qualifier of the column into which new data should be written.
+          #     Can be any byte string, including the empty string.
+          # @!attribute [rw] timestamp_micros
+          #   @return [::Integer]
+          #     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).
+          # @!attribute [rw] value
+          #   @return [::String]
+          #     The value to be written into the specified cell.
+          class SetCell
+            include ::Google::Protobuf::MessageExts
+            extend ::Google::Protobuf::MessageExts::ClassMethods
+          end
+
+          # A Mutation which deletes cells from the specified column, optionally
+          # restricting the deletions to a given timestamp range.
+          # @!attribute [rw] family_name
+          #   @return [::String]
+          #     The name of the family from which cells should be deleted.
+          #     Must match `[-_.a-zA-Z0-9]+`
+          # @!attribute [rw] column_qualifier
+          #   @return [::String]
+          #     The qualifier of the column from which cells should be deleted.
+          #     Can be any byte string, including the empty string.
+          # @!attribute [rw] time_range
+          #   @return [::Google::Cloud::Bigtable::V2::TimestampRange]
+          #     The range of timestamps within which cells should be deleted.
+          class DeleteFromColumn
+            include ::Google::Protobuf::MessageExts
+            extend ::Google::Protobuf::MessageExts::ClassMethods
+          end
+
+          # A Mutation which deletes all cells from the specified column family.
+          # @!attribute [rw] family_name
+          #   @return [::String]
+          #     The name of the family from which cells should be deleted.
+          #     Must match `[-_.a-zA-Z0-9]+`
+          class DeleteFromFamily
+            include ::Google::Protobuf::MessageExts
+            extend ::Google::Protobuf::MessageExts::ClassMethods
+          end
+
+          # A Mutation which deletes all cells from the containing row.
+          class DeleteFromRow
+            include ::Google::Protobuf::MessageExts
+            extend ::Google::Protobuf::MessageExts::ClassMethods
+          end
+        end
+
+        # Specifies an atomic read/modify/write operation on the latest value of the
+        # specified column.
+        # @!attribute [rw] family_name
+        #   @return [::String]
+        #     The name of the family to which the read/modify/write should be applied.
+        #     Must match `[-_.a-zA-Z0-9]+`
+        # @!attribute [rw] column_qualifier
+        #   @return [::String]
+        #     The qualifier of the column to which the read/modify/write should be
+        #     applied.
+        #     Can be any byte string, including the empty string.
+        # @!attribute [rw] append_value
+        #   @return [::String]
+        #     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.
+        # @!attribute [rw] increment_amount
+        #   @return [::Integer]
+        #     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.
+        class ReadModifyWriteRule
+          include ::Google::Protobuf::MessageExts
+          extend ::Google::Protobuf::MessageExts::ClassMethods
+        end
+      end
+    end
+  end
+end