google-apis-bigtableadmin_v2 0.56.0 → 0.58.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e23577923f63d62dc8a2b9d4d8ce2a86534ddf15d2c9c92464b5823928c2ad6
-  data.tar.gz: 02c01f31429b100fc87c41dbb8e71c63b130bded5a4c698530d9ab9834b6db81
+  metadata.gz: 9be357010d76ff45a0e26d20cb9791ef387d2e629cfded0ef129116bec48f773
+  data.tar.gz: fa6111b2fc3fedbe0dddfbce94029e6fc455b9116999c91ab6c6a1b9f63c5e65
 SHA512:
-  metadata.gz: 58a87bb8529a70914249a5c6fe15d4744aa85f47d93a46f687c8e93af05fa37ec6ae2a2c09bdab7950913ded79e3bd25d185e296c1e12664eebffa760e735516
-  data.tar.gz: 1f2d37435e4b0ab7787563d766c39a7010a86168c3dd5e6f1b4e19de22c1a0037a6c9a15fce814239a4e01b1eb3e1d7d63e321ab370a7b43882323e172ccb164
+  metadata.gz: 97b22b1bf94543f2100add67066e09d845b72c9b15e53353652c88dd2da6f7c26e6796cb088400b0e95fdb6ce11aab35eb8c93791a3f926469f540ec1a9331b2
+  data.tar.gz: 4e35a2a4424bdc0e5fb5995212c93f2e032c85311f45cb26822d4d02686db2165d6df2c8df466baaa46850099581ad4683a1883325ccc2f8cf8905bbb8a5f4d2

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Release history for google-apis-bigtableadmin_v2
 
+### v0.58.0 (2024-07-25)
+
+* Regenerated from discovery document revision 20240703
+
+### v0.57.0 (2024-06-16)
+
+* Regenerated from discovery document revision 20240604
+
 ### v0.56.0 (2024-06-09)
 
 * Regenerated from discovery document revision 20240522

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

@@ -314,10 +314,10 @@ module Google
         # @return [String]
         attr_accessor :end_time
       
-        # Required. The expiration time of the backup, with microseconds granularity
-        # that must be at least 6 hours and at most 90 days from the time the request is
-        # received. Once the `expire_time` has passed, Cloud Bigtable will delete the
-        # backup and free the resources used by the backup.
+        # Required. The expiration time of the backup. When creating a backup or
+        # updating its `expire_time`, the new value must: - Be at most 90 days in the
+        # future - Be at least 6 hours in the future Once the `expire_time` has passed,
+        # Cloud Bigtable will delete the backup.
         # Corresponds to the JSON property `expireTime`
         # @return [String]
         attr_accessor :expire_time
@@ -764,26 +764,21 @@ module Google
         # 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: BYTES values sort in the same order as
-        # their raw 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
-        # has this property if *every* link does. * Self-delimiting: If we concatenate
+        # which describes how to convert to/from the underlying data. Each encoding also
+        # defines the following properties: * Order-preserving: 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: BYTES values sort in the same order as their raw encodings. -
+        # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
+        # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
+        # but STRING("-00001") > STRING("00001). * 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 has this property
-        # if *any* link does. * Compatibility: Which other systems have matching
-        # encoding schemes? For example, does this encoding have a GoogleSQL equivalent?
-        # HBase? Java?
+        # tell where the first one ends. * 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
@@ -1596,58 +1591,69 @@ module Google
       class GoogleBigtableAdminV2TypeAggregate
         include Google::Apis::Core::Hashable
       
+        # Computes an approximate unique count over the input values. When using raw
+        # data as input, be careful to use a consistent encoding. Otherwise the same
+        # value encoded differently could count more than once, or two distinct values
+        # could count as identical. Input: Any, or omit for Raw State: TBD Special state
+        # conversions: `Int64` (the unique count estimate)
+        # Corresponds to the JSON property `hllppUniqueCount`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount]
+        attr_accessor :hllpp_unique_count
+      
         # `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: BYTES values sort in the same order as
-        # their raw 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
-        # has this property if *every* link does. * Self-delimiting: If we concatenate
+        # which describes how to convert to/from the underlying data. Each encoding also
+        # defines the following properties: * Order-preserving: 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: BYTES values sort in the same order as their raw encodings. -
+        # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
+        # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
+        # but STRING("-00001") > STRING("00001). * 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 has this property
-        # if *any* link does. * Compatibility: Which other systems have matching
-        # encoding schemes? For example, does this encoding have a GoogleSQL equivalent?
-        # HBase? Java?
+        # tell where the first one ends. * 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
       
+        # Computes the max of the input values. Allowed input: `Int64` State: same as
+        # input
+        # Corresponds to the JSON property `max`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateMax]
+        attr_accessor :max
+      
+        # Computes the min of the input values. Allowed input: `Int64` State: same as
+        # input
+        # Corresponds to the JSON property `min`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateMin]
+        attr_accessor :min
+      
         # `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: BYTES values sort in the same order as
-        # their raw 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
-        # has this property if *every* link does. * Self-delimiting: If we concatenate
+        # which describes how to convert to/from the underlying data. Each encoding also
+        # defines the following properties: * Order-preserving: 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: BYTES values sort in the same order as their raw encodings. -
+        # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
+        # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
+        # but STRING("-00001") > STRING("00001). * 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 has this property
-        # if *any* link does. * Compatibility: Which other systems have matching
-        # encoding schemes? For example, does this encoding have a GoogleSQL equivalent?
-        # HBase? Java?
+        # tell where the first one ends. * 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
@@ -1664,12 +1670,60 @@ module Google
       
         # Update properties of this object
         def update!(**args)
+          @hllpp_unique_count = args[:hllpp_unique_count] if args.key?(:hllpp_unique_count)
           @input_type = args[:input_type] if args.key?(:input_type)
+          @max = args[:max] if args.key?(:max)
+          @min = args[:min] if args.key?(:min)
           @state_type = args[:state_type] if args.key?(:state_type)
           @sum = args[:sum] if args.key?(:sum)
         end
       end
       
+      # Computes an approximate unique count over the input values. When using raw
+      # data as input, be careful to use a consistent encoding. Otherwise the same
+      # value encoded differently could count more than once, or two distinct values
+      # could count as identical. Input: Any, or omit for Raw State: TBD Special state
+      # conversions: `Int64` (the unique count estimate)
+      class GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # Computes the max of the input values. Allowed input: `Int64` State: same as
+      # input
+      class GoogleBigtableAdminV2TypeAggregateMax
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # Computes the min of the input values. Allowed input: `Int64` State: same as
+      # input
+      class GoogleBigtableAdminV2TypeAggregateMin
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
       # Computes the sum of the input values. Allowed input: `Int64` State: same as
       # input
       class GoogleBigtableAdminV2TypeAggregateSum
@@ -1684,6 +1738,57 @@ module Google
         end
       end
       
+      # An ordered list of elements of a given type. Values of type `Array` are stored
+      # in `Value.array_value`.
+      class GoogleBigtableAdminV2TypeArray
+        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. Each encoding also
+        # defines the following properties: * Order-preserving: 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: BYTES values sort in the same order as their raw encodings. -
+        # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
+        # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
+        # but STRING("-00001") > STRING("00001). * 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. * Compatibility: Which other systems have
+        # matching encoding schemes? For example, does this encoding have a GoogleSQL
+        # equivalent? HBase? Java?
+        # Corresponds to the JSON property `elementType`
+        # @return [Google::Apis::BigtableadminV2::Type]
+        attr_accessor :element_type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @element_type = args[:element_type] if args.key?(:element_type)
+        end
+      end
+      
+      # bool Values of type `Bool` are stored in `Value.bool_value`.
+      class GoogleBigtableAdminV2TypeBool
+        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
@@ -1707,7 +1812,7 @@ module Google
       class GoogleBigtableAdminV2TypeBytesEncoding
         include Google::Apis::Core::Hashable
       
-        # Leaves the value "as-is" * Natural sort? Yes * Self-delimiting? No *
+        # Leaves the value "as-is" * Order-preserving? Yes * Self-delimiting? No *
         # Compatibility? N/A
         # Corresponds to the JSON property `raw`
         # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytesEncodingRaw]
@@ -1723,7 +1828,7 @@ module Google
         end
       end
       
-      # Leaves the value "as-is" * Natural sort? Yes * Self-delimiting? No *
+      # Leaves the value "as-is" * Order-preserving? Yes * Self-delimiting? No *
       # Compatibility? N/A
       class GoogleBigtableAdminV2TypeBytesEncodingRaw
         include Google::Apis::Core::Hashable
@@ -1737,6 +1842,45 @@ module Google
         end
       end
       
+      # Date Values of type `Date` are stored in `Value.date_value`.
+      class GoogleBigtableAdminV2TypeDate
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # Float32 Values of type `Float32` are stored in `Value.float_value`.
+      class GoogleBigtableAdminV2TypeFloat32
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # Float64 Values of type `Float64` are stored in `Value.float_value`.
+      class GoogleBigtableAdminV2TypeFloat64
+        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
@@ -1761,9 +1905,9 @@ module Google
         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`
+        # Order-preserving? 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
@@ -1779,9 +1923,9 @@ module Google
       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`
+      # Order-preserving? 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
       
@@ -1800,6 +1944,205 @@ module Google
         end
       end
       
+      # A mapping of keys to values of a given type. Values of type `Map` are stored
+      # in a `Value.array_value` where each entry is another `Value.array_value` with
+      # two elements (the key and the value, in that order). Normally encoded Map
+      # values won't have repeated keys, however, clients are expected to handle the
+      # case in which they do. If the same key appears multiple times, the _last_
+      # value takes precedence.
+      class GoogleBigtableAdminV2TypeMap
+        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. Each encoding also
+        # defines the following properties: * Order-preserving: 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: BYTES values sort in the same order as their raw encodings. -
+        # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
+        # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
+        # but STRING("-00001") > STRING("00001). * 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. * Compatibility: Which other systems have
+        # matching encoding schemes? For example, does this encoding have a GoogleSQL
+        # equivalent? HBase? Java?
+        # Corresponds to the JSON property `keyType`
+        # @return [Google::Apis::BigtableadminV2::Type]
+        attr_accessor :key_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. Each encoding also
+        # defines the following properties: * Order-preserving: 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: BYTES values sort in the same order as their raw encodings. -
+        # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
+        # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
+        # but STRING("-00001") > STRING("00001). * 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. * 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
+      
+        # Update properties of this object
+        def update!(**args)
+          @key_type = args[:key_type] if args.key?(:key_type)
+          @value_type = args[:value_type] if args.key?(:value_type)
+        end
+      end
+      
+      # String Values of type `String` are stored in `Value.string_value`.
+      class GoogleBigtableAdminV2TypeString
+        include Google::Apis::Core::Hashable
+      
+        # Rules used to convert to/from lower level types.
+        # Corresponds to the JSON property `encoding`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStringEncoding]
+        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 GoogleBigtableAdminV2TypeStringEncoding
+        include Google::Apis::Core::Hashable
+      
+        # UTF-8 encoding * Order-preserving? Yes (code point order) * Self-delimiting?
+        # No * Compatibility? - BigQuery Federation `TEXT` encoding - HBase `Bytes.
+        # toBytes` - Java `String#getBytes(StandardCharsets.UTF_8)`
+        # Corresponds to the JSON property `utf8Bytes`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes]
+        attr_accessor :utf8_bytes
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @utf8_bytes = args[:utf8_bytes] if args.key?(:utf8_bytes)
+        end
+      end
+      
+      # UTF-8 encoding * Order-preserving? Yes (code point order) * Self-delimiting?
+      # No * Compatibility? - BigQuery Federation `TEXT` encoding - HBase `Bytes.
+      # toBytes` - Java `String#getBytes(StandardCharsets.UTF_8)`
+      class GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # A structured data value, consisting of fields which map to dynamically typed
+      # values. Values of type `Struct` are stored in `Value.array_value` where
+      # entries are in the same order and number as `field_types`.
+      class GoogleBigtableAdminV2TypeStruct
+        include Google::Apis::Core::Hashable
+      
+        # The names and types of the fields in this struct.
+        # Corresponds to the JSON property `fields`
+        # @return [Array<Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStructField>]
+        attr_accessor :fields
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @fields = args[:fields] if args.key?(:fields)
+        end
+      end
+      
+      # A struct field and its type.
+      class GoogleBigtableAdminV2TypeStructField
+        include Google::Apis::Core::Hashable
+      
+        # The field name (optional). Fields without a `field_name` are considered
+        # anonymous and cannot be referenced by name.
+        # Corresponds to the JSON property `fieldName`
+        # @return [String]
+        attr_accessor :field_name
+      
+        # `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. Each encoding also
+        # defines the following properties: * Order-preserving: 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: BYTES values sort in the same order as their raw encodings. -
+        # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
+        # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
+        # but STRING("-00001") > STRING("00001). * 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. * Compatibility: Which other systems have
+        # matching encoding schemes? For example, does this encoding have a GoogleSQL
+        # equivalent? HBase? Java?
+        # Corresponds to the JSON property `type`
+        # @return [Google::Apis::BigtableadminV2::Type]
+        attr_accessor :type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @field_name = args[:field_name] if args.key?(:field_name)
+          @type = args[:type] if args.key?(:type)
+        end
+      end
+      
+      # Timestamp Values of type `Timestamp` are stored in `Value.timestamp_value`.
+      class GoogleBigtableAdminV2TypeTimestamp
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        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
@@ -3163,26 +3506,21 @@ module Google
       # 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: BYTES values sort in the same order as
-      # their raw 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
-      # has this property if *every* link does. * Self-delimiting: If we concatenate
+      # which describes how to convert to/from the underlying data. Each encoding also
+      # defines the following properties: * Order-preserving: 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: BYTES values sort in the same order as their raw encodings. -
+      # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
+      # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
+      # but STRING("-00001") > STRING("00001). * 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 has this property
-      # if *any* link does. * Compatibility: Which other systems have matching
-      # encoding schemes? For example, does this encoding have a GoogleSQL equivalent?
-      # HBase? Java?
+      # tell where the first one ends. * 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
       
@@ -3194,16 +3532,69 @@ module Google
         # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregate]
         attr_accessor :aggregate_type
       
+        # An ordered list of elements of a given type. Values of type `Array` are stored
+        # in `Value.array_value`.
+        # Corresponds to the JSON property `arrayType`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeArray]
+        attr_accessor :array_type
+      
+        # bool Values of type `Bool` are stored in `Value.bool_value`.
+        # Corresponds to the JSON property `boolType`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBool]
+        attr_accessor :bool_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
       
+        # Date Values of type `Date` are stored in `Value.date_value`.
+        # Corresponds to the JSON property `dateType`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeDate]
+        attr_accessor :date_type
+      
+        # Float32 Values of type `Float32` are stored in `Value.float_value`.
+        # Corresponds to the JSON property `float32Type`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeFloat32]
+        attr_accessor :float32_type
+      
+        # Float64 Values of type `Float64` are stored in `Value.float_value`.
+        # Corresponds to the JSON property `float64Type`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeFloat64]
+        attr_accessor :float64_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
       
+        # A mapping of keys to values of a given type. Values of type `Map` are stored
+        # in a `Value.array_value` where each entry is another `Value.array_value` with
+        # two elements (the key and the value, in that order). Normally encoded Map
+        # values won't have repeated keys, however, clients are expected to handle the
+        # case in which they do. If the same key appears multiple times, the _last_
+        # value takes precedence.
+        # Corresponds to the JSON property `mapType`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeMap]
+        attr_accessor :map_type
+      
+        # String Values of type `String` are stored in `Value.string_value`.
+        # Corresponds to the JSON property `stringType`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeString]
+        attr_accessor :string_type
+      
+        # A structured data value, consisting of fields which map to dynamically typed
+        # values. Values of type `Struct` are stored in `Value.array_value` where
+        # entries are in the same order and number as `field_types`.
+        # Corresponds to the JSON property `structType`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStruct]
+        attr_accessor :struct_type
+      
+        # Timestamp Values of type `Timestamp` are stored in `Value.timestamp_value`.
+        # Corresponds to the JSON property `timestampType`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeTimestamp]
+        attr_accessor :timestamp_type
+      
         def initialize(**args)
            update!(**args)
         end
@@ -3211,8 +3602,17 @@ module Google
         # Update properties of this object
         def update!(**args)
           @aggregate_type = args[:aggregate_type] if args.key?(:aggregate_type)
+          @array_type = args[:array_type] if args.key?(:array_type)
+          @bool_type = args[:bool_type] if args.key?(:bool_type)
           @bytes_type = args[:bytes_type] if args.key?(:bytes_type)
+          @date_type = args[:date_type] if args.key?(:date_type)
+          @float32_type = args[:float32_type] if args.key?(:float32_type)
+          @float64_type = args[:float64_type] if args.key?(:float64_type)
           @int64_type = args[:int64_type] if args.key?(:int64_type)
+          @map_type = args[:map_type] if args.key?(:map_type)
+          @string_type = args[:string_type] if args.key?(:string_type)
+          @struct_type = args[:struct_type] if args.key?(:struct_type)
+          @timestamp_type = args[:timestamp_type] if args.key?(:timestamp_type)
         end
       end
       

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.56.0"
+      GEM_VERSION = "0.58.0"
 
       # Version of the code generator used to generate this client
       GENERATOR_VERSION = "0.15.0"
 
       # Revision of the discovery document this client was generated from
-      REVISION = "20240522"
+      REVISION = "20240703"
     end
   end
 end

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

@@ -286,12 +286,42 @@ module Google
         include Google::Apis::Core::JsonObjectSupport
       end
       
+      class GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeAggregateMax
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeAggregateMin
+        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 GoogleBigtableAdminV2TypeArray
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeBool
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
       class GoogleBigtableAdminV2TypeBytes
         class Representation < Google::Apis::Core::JsonRepresentation; end
       
@@ -310,6 +340,24 @@ module Google
         include Google::Apis::Core::JsonObjectSupport
       end
       
+      class GoogleBigtableAdminV2TypeDate
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeFloat32
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeFloat64
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
       class GoogleBigtableAdminV2TypeInt64
         class Representation < Google::Apis::Core::JsonRepresentation; end
       
@@ -328,6 +376,48 @@ module Google
         include Google::Apis::Core::JsonObjectSupport
       end
       
+      class GoogleBigtableAdminV2TypeMap
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeString
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeStringEncoding
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeStruct
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeStructField
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleBigtableAdminV2TypeTimestamp
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
       class HotTablet
         class Representation < Google::Apis::Core::JsonRepresentation; end
       
@@ -1024,8 +1114,14 @@ module Google
       class GoogleBigtableAdminV2TypeAggregate
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation
+          property :hllpp_unique_count, as: 'hllppUniqueCount', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount::Representation
+      
           property :input_type, as: 'inputType', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
       
+          property :max, as: 'max', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateMax, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateMax::Representation
+      
+          property :min, as: 'min', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateMin, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateMin::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
@@ -1033,12 +1129,44 @@ module Google
         end
       end
       
+      class GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeAggregateMax
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeAggregateMin
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+        end
+      end
+      
       class GoogleBigtableAdminV2TypeAggregateSum
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation
         end
       end
       
+      class GoogleBigtableAdminV2TypeArray
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :element_type, as: 'elementType', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
+      
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeBool
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+        end
+      end
+      
       class GoogleBigtableAdminV2TypeBytes
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation
@@ -1061,6 +1189,24 @@ module Google
         end
       end
       
+      class GoogleBigtableAdminV2TypeDate
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeFloat32
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeFloat64
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+        end
+      end
+      
       class GoogleBigtableAdminV2TypeInt64
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation
@@ -1085,6 +1231,61 @@ module Google
         end
       end
       
+      class GoogleBigtableAdminV2TypeMap
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :key_type, as: 'keyType', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
+      
+          property :value_type, as: 'valueType', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
+      
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeString
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :encoding, as: 'encoding', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStringEncoding, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStringEncoding::Representation
+      
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeStringEncoding
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :utf8_bytes, as: 'utf8Bytes', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes::Representation
+      
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeStruct
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          collection :fields, as: 'fields', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStructField, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStructField::Representation
+      
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeStructField
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :field_name, as: 'fieldName'
+          property :type, as: 'type', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
+      
+        end
+      end
+      
+      class GoogleBigtableAdminV2TypeTimestamp
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+        end
+      end
+      
       class HotTablet
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation
@@ -1449,10 +1650,28 @@ module Google
         class Representation < Google::Apis::Core::JsonRepresentation
           property :aggregate_type, as: 'aggregateType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregate, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregate::Representation
       
+          property :array_type, as: 'arrayType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeArray, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeArray::Representation
+      
+          property :bool_type, as: 'boolType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBool, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBool::Representation
+      
           property :bytes_type, as: 'bytesType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytes, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytes::Representation
       
+          property :date_type, as: 'dateType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeDate, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeDate::Representation
+      
+          property :float32_type, as: 'float32Type', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeFloat32, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeFloat32::Representation
+      
+          property :float64_type, as: 'float64Type', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeFloat64, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeFloat64::Representation
+      
           property :int64_type, as: 'int64Type', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64::Representation
       
+          property :map_type, as: 'mapType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeMap, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeMap::Representation
+      
+          property :string_type, as: 'stringType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeString, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeString::Representation
+      
+          property :struct_type, as: 'structType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStruct, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStruct::Representation
+      
+          property :timestamp_type, as: 'timestampType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeTimestamp, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeTimestamp::Representation
+      
         end
       end
       

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

@@ -856,7 +856,7 @@ module Google
         # located in the destination instance and project.
         # @param [String] parent
         #   Required. The name of the destination cluster that will contain the backup
-        #   copy. The cluster must already exists. Values are of the form: `projects/`
+        #   copy. The cluster must already exist. Values are of the form: `projects/`
         #   project`/instances/`instance`/clusters/`cluster``.
         # @param [Google::Apis::BigtableadminV2::CopyBackupRequest] copy_backup_request_object
         # @param [String] fields

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: google-apis-bigtableadmin_v2
 version: !ruby/object:Gem::Version
-  version: 0.56.0
+  version: 0.58.0
 platform: ruby
 authors:
 - Google LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-06-09 00:00:00.000000000 Z
+date: 2024-07-25 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.56.0
+  documentation_uri: https://googleapis.dev/ruby/google-apis-bigtableadmin_v2/v0.58.0
   source_code_uri: https://github.com/googleapis/google-api-ruby-client/tree/main/generated/google-apis-bigtableadmin_v2
 post_install_message: 
 rdoc_options: []