google-apis-bigtableadmin_v2 0.50.0 → 0.51.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f14ac5ffddc632286104598464ca69ca516cbbf2c7f5616a54ecc1448445e2ae
-  data.tar.gz: 0e3a6714cd5e841001f224445d66ddd0240543967a5c0e994bd01745fffd64f7
+  metadata.gz: 37145309b5f7c7e1ccad2680e5aa4b09a835128bd60381b5ee1911cacc0b5b9c
+  data.tar.gz: 8557c471a7b6cf534608520ba9bb90cab901903da09bd74ceb808bacbd86a0c3
 SHA512:
-  metadata.gz: 836450503ef7e2ab4554b9b1fe28b6623c4a874871aeff80a43f2643454ac806267d3524e36887e514dae51ebf11f5e60c077738b0f9fe683d080cbde22a5799
-  data.tar.gz: 040f4fea973c5422b65e015ce3fe305d853220bd62aff551f22153060e73ac631be5ec75a39a1343804d3729ebbec745a9e0cdddb5a4e65209840f53895e6987
+  metadata.gz: fce03e6241ad393ca83f77f2fa0f8daa3028481fc283834b025523fd7bf74a4d2b5f5b0a543e9fe4a26c5b288861978172ca59c922c9d3d66af621c1d3f860ea
+  data.tar.gz: 6894d2f0432b042aa0c78a89178c78454f4e8f92969fc7164b9c0d85fb27297baae412f35e9d59915f456c3f84c2bbdcd9df5556a7b157e29869442d17278d32

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Release history for google-apis-bigtableadmin_v2
 
+### v0.51.0 (2024-03-24)
+
+* Regenerated from discovery document revision 20240318
+
 ### v0.50.0 (2024-03-17)
 
 * Regenerated from discovery document revision 20240306

data/lib/google/apis/bigtableadmin_v2/classes.rb

@@ -27,6 +27,19 @@ module Google
       class AppProfile
         include Google::Apis::Core::Hashable
       
+        # Data Boost is a serverless compute capability that lets you run high-
+        # throughput read jobs on your Bigtable data, without impacting the performance
+        # of the clusters that handle your application traffic. Currently, Data Boost
+        # exclusively supports read-only use-cases with single-cluster routing. Data
+        # Boost reads are only guaranteed to see the results of writes that were written
+        # at least 30 minutes ago. This means newly written values may not become
+        # visible for up to 30m, and also means that old values may remain visible for
+        # up to 30m after being deleted or overwritten. To mitigate the staleness of the
+        # data, users may either wait 30m, or use CheckConsistency.
+        # Corresponds to the JSON property `dataBoostIsolationReadOnly`
+        # @return [Google::Apis::BigtableadminV2::DataBoostIsolationReadOnly]
+        attr_accessor :data_boost_isolation_read_only
+      
         # Long form description of the use case for this AppProfile.
         # Corresponds to the JSON property `description`
         # @return [String]
@@ -82,6 +95,7 @@ module Google
       
         # Update properties of this object
         def update!(**args)
+          @data_boost_isolation_read_only = args[:data_boost_isolation_read_only] if args.key?(:data_boost_isolation_read_only)
           @description = args[:description] if args.key?(:description)
           @etag = args[:etag] if args.key?(:etag)
           @multi_cluster_routing_use_any = args[:multi_cluster_routing_use_any] if args.key?(:multi_cluster_routing_use_any)
@@ -552,6 +566,18 @@ module Google
         # @return [String]
         attr_accessor :consistency_token
       
+        # Checks that all writes before the consistency token was generated in the same
+        # cluster are readable by Databoost.
+        # Corresponds to the JSON property `dataBoostReadLocalWrites`
+        # @return [Google::Apis::BigtableadminV2::DataBoostReadLocalWrites]
+        attr_accessor :data_boost_read_local_writes
+      
+        # Checks that all writes before the consistency token was generated are
+        # replicated in every cluster and readable.
+        # Corresponds to the JSON property `standardReadRemoteWrites`
+        # @return [Google::Apis::BigtableadminV2::StandardReadRemoteWrites]
+        attr_accessor :standard_read_remote_writes
+      
         def initialize(**args)
            update!(**args)
         end
@@ -559,6 +585,8 @@ module Google
         # Update properties of this object
         def update!(**args)
           @consistency_token = args[:consistency_token] if args.key?(:consistency_token)
+          @data_boost_read_local_writes = args[:data_boost_read_local_writes] if args.key?(:data_boost_read_local_writes)
+          @standard_read_remote_writes = args[:standard_read_remote_writes] if args.key?(:standard_read_remote_writes)
         end
       end
       
@@ -737,6 +765,34 @@ module Google
         # @return [Google::Apis::BigtableadminV2::ColumnFamilyStats]
         attr_accessor :stats
       
+        # `Type` represents the type of data that is written to, read from, or stored in
+        # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
+        # familiarity and consistency across products and features. For compatibility
+        # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
+        # which describes how to convert to/from the underlying data. This might involve
+        # composing a series of steps into an "encoding chain," for example to convert
+        # from INT64 -> STRING -> raw bytes. In most cases, a "link" in the encoding
+        # chain will be based an on existing GoogleSQL conversion function like `CAST`.
+        # Each link in the encoding chain also defines the following properties: *
+        # Natural sort: Does the encoded value sort consistently with the original typed
+        # value? Note that Bigtable will always sort data based on the raw encoded value,
+        # *not* the decoded type. - Example: STRING values sort in the same order as
+        # their UTF-8 encodings. - Counterexample: Encoding INT64 to a fixed-width
+        # STRING does *not* preserve sort order when dealing with negative numbers.
+        # INT64(1) > INT64(-1), but STRING("-00001") > STRING("00001). - The overall
+        # encoding chain sorts naturally if *every* link does. * Self-delimiting: If we
+        # concatenate two encoded values, can we always tell where the first one ends
+        # and the second one begins? - Example: If we encode INT64s to fixed-width
+        # STRINGs, the first value will always contain exactly N digits, possibly
+        # preceded by a sign. - Counterexample: If we concatenate two UTF-8 encoded
+        # STRINGs, we have no way to tell where the first one ends. - The overall
+        # encoding chain is self-delimiting if *any* link is. * Compatibility: Which
+        # other systems have matching encoding schemes? For example, does this encoding
+        # have a GoogleSQL equivalent? HBase? Java?
+        # Corresponds to the JSON property `valueType`
+        # @return [Google::Apis::BigtableadminV2::Type]
+        attr_accessor :value_type
+      
         def initialize(**args)
            update!(**args)
         end
@@ -745,6 +801,7 @@ module Google
         def update!(**args)
           @gc_rule = args[:gc_rule] if args.key?(:gc_rule)
           @stats = args[:stats] if args.key?(:stats)
+          @value_type = args[:value_type] if args.key?(:value_type)
         end
       end
       
@@ -1166,6 +1223,47 @@ module Google
         end
       end
       
+      # Data Boost is a serverless compute capability that lets you run high-
+      # throughput read jobs on your Bigtable data, without impacting the performance
+      # of the clusters that handle your application traffic. Currently, Data Boost
+      # exclusively supports read-only use-cases with single-cluster routing. Data
+      # Boost reads are only guaranteed to see the results of writes that were written
+      # at least 30 minutes ago. This means newly written values may not become
+      # visible for up to 30m, and also means that old values may remain visible for
+      # up to 30m after being deleted or overwritten. To mitigate the staleness of the
+      # data, users may either wait 30m, or use CheckConsistency.
+      class DataBoostIsolationReadOnly
+        include Google::Apis::Core::Hashable
+      
+        # The Compute Billing Owner for this Data Boost App Profile.
+        # Corresponds to the JSON property `computeBillingOwner`
+        # @return [String]
+        attr_accessor :compute_billing_owner
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @compute_billing_owner = args[:compute_billing_owner] if args.key?(:compute_billing_owner)
+        end
+      end
+      
+      # Checks that all writes before the consistency token was generated in the same
+      # cluster are readable by Databoost.
+      class DataBoostReadLocalWrites
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
       # Request message for google.bigtable.admin.v2.BigtableTableAdmin.DropRowRange
       class DropRowRangeRequest
         include Google::Apis::Core::Hashable
@@ -1501,6 +1599,217 @@ module Google
         end
       end
       
+      # A value that combines incremental updates into a summarized value. Data is
+      # never directly written or read using type `Aggregate`. Writes will provide
+      # either the `input_type` or `state_type`, and reads will always return the `
+      # state_type` .
+      class GoogleBigtableAdminV2TypeAggregate
+        include Google::Apis::Core::Hashable
+      
+        # `Type` represents the type of data that is written to, read from, or stored in
+        # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
+        # familiarity and consistency across products and features. For compatibility
+        # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
+        # which describes how to convert to/from the underlying data. This might involve
+        # composing a series of steps into an "encoding chain," for example to convert
+        # from INT64 -> STRING -> raw bytes. In most cases, a "link" in the encoding
+        # chain will be based an on existing GoogleSQL conversion function like `CAST`.
+        # Each link in the encoding chain also defines the following properties: *
+        # Natural sort: Does the encoded value sort consistently with the original typed
+        # value? Note that Bigtable will always sort data based on the raw encoded value,
+        # *not* the decoded type. - Example: STRING values sort in the same order as
+        # their UTF-8 encodings. - Counterexample: Encoding INT64 to a fixed-width
+        # STRING does *not* preserve sort order when dealing with negative numbers.
+        # INT64(1) > INT64(-1), but STRING("-00001") > STRING("00001). - The overall
+        # encoding chain sorts naturally if *every* link does. * Self-delimiting: If we
+        # concatenate two encoded values, can we always tell where the first one ends
+        # and the second one begins? - Example: If we encode INT64s to fixed-width
+        # STRINGs, the first value will always contain exactly N digits, possibly
+        # preceded by a sign. - Counterexample: If we concatenate two UTF-8 encoded
+        # STRINGs, we have no way to tell where the first one ends. - The overall
+        # encoding chain is self-delimiting if *any* link is. * Compatibility: Which
+        # other systems have matching encoding schemes? For example, does this encoding
+        # have a GoogleSQL equivalent? HBase? Java?
+        # Corresponds to the JSON property `inputType`
+        # @return [Google::Apis::BigtableadminV2::Type]
+        attr_accessor :input_type
+      
+        # `Type` represents the type of data that is written to, read from, or stored in
+        # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
+        # familiarity and consistency across products and features. For compatibility
+        # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
+        # which describes how to convert to/from the underlying data. This might involve
+        # composing a series of steps into an "encoding chain," for example to convert
+        # from INT64 -> STRING -> raw bytes. In most cases, a "link" in the encoding
+        # chain will be based an on existing GoogleSQL conversion function like `CAST`.
+        # Each link in the encoding chain also defines the following properties: *
+        # Natural sort: Does the encoded value sort consistently with the original typed
+        # value? Note that Bigtable will always sort data based on the raw encoded value,
+        # *not* the decoded type. - Example: STRING values sort in the same order as
+        # their UTF-8 encodings. - Counterexample: Encoding INT64 to a fixed-width
+        # STRING does *not* preserve sort order when dealing with negative numbers.
+        # INT64(1) > INT64(-1), but STRING("-00001") > STRING("00001). - The overall
+        # encoding chain sorts naturally if *every* link does. * Self-delimiting: If we
+        # concatenate two encoded values, can we always tell where the first one ends
+        # and the second one begins? - Example: If we encode INT64s to fixed-width
+        # STRINGs, the first value will always contain exactly N digits, possibly
+        # preceded by a sign. - Counterexample: If we concatenate two UTF-8 encoded
+        # STRINGs, we have no way to tell where the first one ends. - The overall
+        # encoding chain is self-delimiting if *any* link is. * Compatibility: Which
+        # other systems have matching encoding schemes? For example, does this encoding
+        # have a GoogleSQL equivalent? HBase? Java?
+        # Corresponds to the JSON property `stateType`
+        # @return [Google::Apis::BigtableadminV2::Type]
+        attr_accessor :state_type
+      
+        # Computes the sum of the input values. Allowed input: `Int64` State: same as
+        # input
+        # Corresponds to the JSON property `sum`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateSum]
+        attr_accessor :sum
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @input_type = args[:input_type] if args.key?(:input_type)
+          @state_type = args[:state_type] if args.key?(:state_type)
+          @sum = args[:sum] if args.key?(:sum)
+        end
+      end
+      
+      # Computes the sum of the input values. Allowed input: `Int64` State: same as
+      # input
+      class GoogleBigtableAdminV2TypeAggregateSum
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # Bytes Values of type `Bytes` are stored in `Value.bytes_value`.
+      class GoogleBigtableAdminV2TypeBytes
+        include Google::Apis::Core::Hashable
+      
+        # Rules used to convert to/from lower level types.
+        # Corresponds to the JSON property `encoding`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytesEncoding]
+        attr_accessor :encoding
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @encoding = args[:encoding] if args.key?(:encoding)
+        end
+      end
+      
+      # Rules used to convert to/from lower level types.
+      class GoogleBigtableAdminV2TypeBytesEncoding
+        include Google::Apis::Core::Hashable
+      
+        # Leaves the value "as-is" * Natural sort? Yes * Self-delimiting? No *
+        # Compatibility? N/A
+        # Corresponds to the JSON property `raw`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytesEncodingRaw]
+        attr_accessor :raw
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @raw = args[:raw] if args.key?(:raw)
+        end
+      end
+      
+      # Leaves the value "as-is" * Natural sort? Yes * Self-delimiting? No *
+      # Compatibility? N/A
+      class GoogleBigtableAdminV2TypeBytesEncodingRaw
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # Int64 Values of type `Int64` are stored in `Value.int_value`.
+      class GoogleBigtableAdminV2TypeInt64
+        include Google::Apis::Core::Hashable
+      
+        # Rules used to convert to/from lower level types.
+        # Corresponds to the JSON property `encoding`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64Encoding]
+        attr_accessor :encoding
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @encoding = args[:encoding] if args.key?(:encoding)
+        end
+      end
+      
+      # Rules used to convert to/from lower level types.
+      class GoogleBigtableAdminV2TypeInt64Encoding
+        include Google::Apis::Core::Hashable
+      
+        # Encodes the value as an 8-byte big endian twos complement `Bytes` value. *
+        # Natural sort? No (positive values only) * Self-delimiting? Yes * Compatibility?
+        # - BigQuery Federation `BINARY` encoding - HBase `Bytes.toBytes` - Java `
+        # ByteBuffer.putLong()` with `ByteOrder.BIG_ENDIAN`
+        # Corresponds to the JSON property `bigEndianBytes`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes]
+        attr_accessor :big_endian_bytes
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @big_endian_bytes = args[:big_endian_bytes] if args.key?(:big_endian_bytes)
+        end
+      end
+      
+      # Encodes the value as an 8-byte big endian twos complement `Bytes` value. *
+      # Natural sort? No (positive values only) * Self-delimiting? Yes * Compatibility?
+      # - BigQuery Federation `BINARY` encoding - HBase `Bytes.toBytes` - Java `
+      # ByteBuffer.putLong()` with `ByteOrder.BIG_ENDIAN`
+      class GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes
+        include Google::Apis::Core::Hashable
+      
+        # Bytes Values of type `Bytes` are stored in `Value.bytes_value`.
+        # Corresponds to the JSON property `bytesType`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytes]
+        attr_accessor :bytes_type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @bytes_type = args[:bytes_type] if args.key?(:bytes_type)
+        end
+      end
+      
       # A tablet is a defined by a start and end key and is explained in https://cloud.
       # google.com/bigtable/docs/overview#architecture and https://cloud.google.com/
       # bigtable/docs/performance#optimization. A Hot tablet is a tablet that exhibits
@@ -2589,6 +2898,20 @@ module Google
         end
       end
       
+      # Checks that all writes before the consistency token was generated are
+      # replicated in every cluster and readable.
+      class StandardReadRemoteWrites
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
       # The `Status` type defines a logical error model that is suitable for different
       # programming environments, including REST APIs and RPC APIs. It is used by [
       # gRPC](https://github.com/grpc). Each `Status` message contains three pieces of
@@ -2839,6 +3162,63 @@ module Google
         end
       end
       
+      # `Type` represents the type of data that is written to, read from, or stored in
+      # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
+      # familiarity and consistency across products and features. For compatibility
+      # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
+      # which describes how to convert to/from the underlying data. This might involve
+      # composing a series of steps into an "encoding chain," for example to convert
+      # from INT64 -> STRING -> raw bytes. In most cases, a "link" in the encoding
+      # chain will be based an on existing GoogleSQL conversion function like `CAST`.
+      # Each link in the encoding chain also defines the following properties: *
+      # Natural sort: Does the encoded value sort consistently with the original typed
+      # value? Note that Bigtable will always sort data based on the raw encoded value,
+      # *not* the decoded type. - Example: STRING values sort in the same order as
+      # their UTF-8 encodings. - Counterexample: Encoding INT64 to a fixed-width
+      # STRING does *not* preserve sort order when dealing with negative numbers.
+      # INT64(1) > INT64(-1), but STRING("-00001") > STRING("00001). - The overall
+      # encoding chain sorts naturally if *every* link does. * Self-delimiting: If we
+      # concatenate two encoded values, can we always tell where the first one ends
+      # and the second one begins? - Example: If we encode INT64s to fixed-width
+      # STRINGs, the first value will always contain exactly N digits, possibly
+      # preceded by a sign. - Counterexample: If we concatenate two UTF-8 encoded
+      # STRINGs, we have no way to tell where the first one ends. - The overall
+      # encoding chain is self-delimiting if *any* link is. * Compatibility: Which
+      # other systems have matching encoding schemes? For example, does this encoding
+      # have a GoogleSQL equivalent? HBase? Java?
+      class Type
+        include Google::Apis::Core::Hashable
+      
+        # A value that combines incremental updates into a summarized value. Data is
+        # never directly written or read using type `Aggregate`. Writes will provide
+        # either the `input_type` or `state_type`, and reads will always return the `
+        # state_type` .
+        # Corresponds to the JSON property `aggregateType`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregate]
+        attr_accessor :aggregate_type
+      
+        # Bytes Values of type `Bytes` are stored in `Value.bytes_value`.
+        # Corresponds to the JSON property `bytesType`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytes]
+        attr_accessor :bytes_type
+      
+        # Int64 Values of type `Int64` are stored in `Value.int_value`.
+        # Corresponds to the JSON property `int64Type`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64]
+        attr_accessor :int64_type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @aggregate_type = args[:aggregate_type] if args.key?(:aggregate_type)
+          @bytes_type = args[:bytes_type] if args.key?(:bytes_type)
+          @int64_type = args[:int64_type] if args.key?(:int64_type)
+        end
+      end
+      
       # Metadata type for the operation returned by google.bigtable.admin.v2.
       # BigtableTableAdmin.UndeleteTable.
       class UndeleteTableMetadata

data/lib/google/apis/bigtableadmin_v2/gem_version.rb

@@ -16,13 +16,13 @@ module Google
   module Apis
     module BigtableadminV2
       # Version of the google-apis-bigtableadmin_v2 gem
-      GEM_VERSION = "0.50.0"
+      GEM_VERSION = "0.51.0"
 
       # Version of the code generator used to generate this client
       GENERATOR_VERSION = "0.14.0"
 
       # Revision of the discovery document this client was generated from
-      REVISION = "20240306"
+      REVISION = "20240318"
     end
   end
 end

data/lib/google/apis/bigtableadmin_v2/representations.rb

@@ -196,6 +196,18 @@ module Google
         include Google::Apis::Core::JsonObjectSupport
       end
       
+      class DataBoostIsolationReadOnly
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class DataBoostReadLocalWrites
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
       class DropRowRangeRequest
         class Representation < Google::Apis::Core::JsonRepresentation; end
       
@@ -268,6 +280,54 @@ module Google
         include Google::Apis::Core::JsonObjectSupport
       end
       
+      class GoogleBigtableAdminV2TypeAggregate
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeAggregateSum
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeBytes
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeBytesEncoding
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeBytesEncodingRaw
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeInt64
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeInt64Encoding
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
       class HotTablet
         class Representation < Google::Apis::Core::JsonRepresentation; end
       
@@ -448,6 +508,12 @@ module Google
         include Google::Apis::Core::JsonObjectSupport
       end
       
+      class StandardReadRemoteWrites
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
       class Status
         class Representation < Google::Apis::Core::JsonRepresentation; end
       
@@ -484,6 +550,12 @@ module Google
         include Google::Apis::Core::JsonObjectSupport
       end
       
+      class Type
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
       class UndeleteTableMetadata
         class Representation < Google::Apis::Core::JsonRepresentation; end
       
@@ -541,6 +613,8 @@ module Google
       class AppProfile
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation
+          property :data_boost_isolation_read_only, as: 'dataBoostIsolationReadOnly', class: Google::Apis::BigtableadminV2::DataBoostIsolationReadOnly, decorator: Google::Apis::BigtableadminV2::DataBoostIsolationReadOnly::Representation
+      
           property :description, as: 'description'
           property :etag, as: 'etag'
           property :multi_cluster_routing_use_any, as: 'multiClusterRoutingUseAny', class: Google::Apis::BigtableadminV2::MultiClusterRoutingUseAny, decorator: Google::Apis::BigtableadminV2::MultiClusterRoutingUseAny::Representation
@@ -654,6 +728,10 @@ module Google
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation
           property :consistency_token, as: 'consistencyToken'
+          property :data_boost_read_local_writes, as: 'dataBoostReadLocalWrites', class: Google::Apis::BigtableadminV2::DataBoostReadLocalWrites, decorator: Google::Apis::BigtableadminV2::DataBoostReadLocalWrites::Representation
+      
+          property :standard_read_remote_writes, as: 'standardReadRemoteWrites', class: Google::Apis::BigtableadminV2::StandardReadRemoteWrites, decorator: Google::Apis::BigtableadminV2::StandardReadRemoteWrites::Representation
+      
         end
       end
       
@@ -713,6 +791,8 @@ module Google
       
           property :stats, as: 'stats', class: Google::Apis::BigtableadminV2::ColumnFamilyStats, decorator: Google::Apis::BigtableadminV2::ColumnFamilyStats::Representation
       
+          property :value_type, as: 'valueType', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
+      
         end
       end
       
@@ -830,6 +910,19 @@ module Google
         end
       end
       
+      class DataBoostIsolationReadOnly
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :compute_billing_owner, as: 'computeBillingOwner'
+        end
+      end
+      
+      class DataBoostReadLocalWrites
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+        end
+      end
+      
       class DropRowRangeRequest
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation
@@ -928,6 +1021,70 @@ module Google
         end
       end
       
+      class GoogleBigtableAdminV2TypeAggregate
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :input_type, as: 'inputType', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
+      
+          property :state_type, as: 'stateType', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
+      
+          property :sum, as: 'sum', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateSum, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateSum::Representation
+      
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeAggregateSum
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeBytes
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :encoding, as: 'encoding', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytesEncoding, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytesEncoding::Representation
+      
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeBytesEncoding
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :raw, as: 'raw', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytesEncodingRaw, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytesEncodingRaw::Representation
+      
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeBytesEncodingRaw
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeInt64
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :encoding, as: 'encoding', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64Encoding, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64Encoding::Representation
+      
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeInt64Encoding
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :big_endian_bytes, as: 'bigEndianBytes', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes::Representation
+      
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :bytes_type, as: 'bytesType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytes, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytes::Representation
+      
+        end
+      end
+      
       class HotTablet
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation
@@ -1217,6 +1374,12 @@ module Google
         end
       end
       
+      class StandardReadRemoteWrites
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+        end
+      end
+      
       class Status
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation
@@ -1280,6 +1443,18 @@ module Google
         end
       end
       
+      class Type
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :aggregate_type, as: 'aggregateType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregate, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregate::Representation
+      
+          property :bytes_type, as: 'bytesType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytes, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytes::Representation
+      
+          property :int64_type, as: 'int64Type', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64::Representation
+      
+        end
+      end
+      
       class UndeleteTableMetadata
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: google-apis-bigtableadmin_v2
 version: !ruby/object:Gem::Version
-  version: 0.50.0
+  version: 0.51.0
 platform: ruby
 authors:
 - Google LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-17 00:00:00.000000000 Z
+date: 2024-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-apis-core
@@ -58,7 +58,7 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/googleapis/google-api-ruby-client/issues
   changelog_uri: https://github.com/googleapis/google-api-ruby-client/tree/main/generated/google-apis-bigtableadmin_v2/CHANGELOG.md
-  documentation_uri: https://googleapis.dev/ruby/google-apis-bigtableadmin_v2/v0.50.0
+  documentation_uri: https://googleapis.dev/ruby/google-apis-bigtableadmin_v2/v0.51.0
   source_code_uri: https://github.com/googleapis/google-api-ruby-client/tree/main/generated/google-apis-bigtableadmin_v2
 post_install_message: 
 rdoc_options: []