google-apis-bigtableadmin_v2 0.57.0 → 0.58.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 9f2067c541f73d2053b94481e1aad921f404762d24c8ab1fb097f21af2341187
4
- data.tar.gz: b14e6d46811af6aa61b4f1c4b077bf61cd7609ec7efc220724c357399e684603
3
+ metadata.gz: 9be357010d76ff45a0e26d20cb9791ef387d2e629cfded0ef129116bec48f773
4
+ data.tar.gz: fa6111b2fc3fedbe0dddfbce94029e6fc455b9116999c91ab6c6a1b9f63c5e65
5
5
  SHA512:
6
- metadata.gz: 91eedb26003cf9c756fcf00293847c69fd8ecaf9eb5d70c0b6c712e33f9e1b54e7a448b9a46b3fab4c92846190cfdc25419082816d122132b844423972ffc295
7
- data.tar.gz: 7863be2ef388ec7ab108df123bb04556672258aabdb0c1d06183f3cfdd7a40e7d73b945e8bb602409e8e44cc423ce58e4e1d5c4e7f066b278560e69de44f6130
6
+ metadata.gz: 97b22b1bf94543f2100add67066e09d845b72c9b15e53353652c88dd2da6f7c26e6796cb088400b0e95fdb6ce11aab35eb8c93791a3f926469f540ec1a9331b2
7
+ data.tar.gz: 4e35a2a4424bdc0e5fb5995212c93f2e032c85311f45cb26822d4d02686db2165d6df2c8df466baaa46850099581ad4683a1883325ccc2f8cf8905bbb8a5f4d2
data/CHANGELOG.md CHANGED
@@ -1,5 +1,9 @@
1
1
  # Release history for google-apis-bigtableadmin_v2
2
2
 
3
+ ### v0.58.0 (2024-07-25)
4
+
5
+ * Regenerated from discovery document revision 20240703
6
+
3
7
  ### v0.57.0 (2024-06-16)
4
8
 
5
9
  * Regenerated from discovery document revision 20240604
@@ -764,26 +764,21 @@ module Google
764
764
  # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
765
765
  # familiarity and consistency across products and features. For compatibility
766
766
  # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
767
- # which describes how to convert to/from the underlying data. This might involve
768
- # composing a series of steps into an "encoding chain," for example to convert
769
- # from INT64 -> STRING -> raw bytes. In most cases, a "link" in the encoding
770
- # chain will be based an on existing GoogleSQL conversion function like `CAST`.
771
- # Each link in the encoding chain also defines the following properties: *
772
- # Natural sort: Does the encoded value sort consistently with the original typed
773
- # value? Note that Bigtable will always sort data based on the raw encoded value,
774
- # *not* the decoded type. - Example: BYTES values sort in the same order as
775
- # their raw encodings. - Counterexample: Encoding INT64 to a fixed-width STRING
776
- # does *not* preserve sort order when dealing with negative numbers. INT64(1) >
777
- # INT64(-1), but STRING("-00001") > STRING("00001). - The overall encoding chain
778
- # has this property if *every* link does. * Self-delimiting: If we concatenate
767
+ # which describes how to convert to/from the underlying data. Each encoding also
768
+ # defines the following properties: * Order-preserving: Does the encoded value
769
+ # sort consistently with the original typed value? Note that Bigtable will
770
+ # always sort data based on the raw encoded value, *not* the decoded type. -
771
+ # Example: BYTES values sort in the same order as their raw encodings. -
772
+ # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
773
+ # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
774
+ # but STRING("-00001") > STRING("00001). * Self-delimiting: If we concatenate
779
775
  # two encoded values, can we always tell where the first one ends and the second
780
776
  # one begins? - Example: If we encode INT64s to fixed-width STRINGs, the first
781
777
  # value will always contain exactly N digits, possibly preceded by a sign. -
782
778
  # Counterexample: If we concatenate two UTF-8 encoded STRINGs, we have no way to
783
- # tell where the first one ends. - The overall encoding chain has this property
784
- # if *any* link does. * Compatibility: Which other systems have matching
785
- # encoding schemes? For example, does this encoding have a GoogleSQL equivalent?
786
- # HBase? Java?
779
+ # tell where the first one ends. * Compatibility: Which other systems have
780
+ # matching encoding schemes? For example, does this encoding have a GoogleSQL
781
+ # equivalent? HBase? Java?
787
782
  # Corresponds to the JSON property `valueType`
788
783
  # @return [Google::Apis::BigtableadminV2::Type]
789
784
  attr_accessor :value_type
@@ -1596,58 +1591,69 @@ module Google
1596
1591
  class GoogleBigtableAdminV2TypeAggregate
1597
1592
  include Google::Apis::Core::Hashable
1598
1593
 
1594
+ # Computes an approximate unique count over the input values. When using raw
1595
+ # data as input, be careful to use a consistent encoding. Otherwise the same
1596
+ # value encoded differently could count more than once, or two distinct values
1597
+ # could count as identical. Input: Any, or omit for Raw State: TBD Special state
1598
+ # conversions: `Int64` (the unique count estimate)
1599
+ # Corresponds to the JSON property `hllppUniqueCount`
1600
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount]
1601
+ attr_accessor :hllpp_unique_count
1602
+
1599
1603
  # `Type` represents the type of data that is written to, read from, or stored in
1600
1604
  # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
1601
1605
  # familiarity and consistency across products and features. For compatibility
1602
1606
  # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
1603
- # which describes how to convert to/from the underlying data. This might involve
1604
- # composing a series of steps into an "encoding chain," for example to convert
1605
- # from INT64 -> STRING -> raw bytes. In most cases, a "link" in the encoding
1606
- # chain will be based an on existing GoogleSQL conversion function like `CAST`.
1607
- # Each link in the encoding chain also defines the following properties: *
1608
- # Natural sort: Does the encoded value sort consistently with the original typed
1609
- # value? Note that Bigtable will always sort data based on the raw encoded value,
1610
- # *not* the decoded type. - Example: BYTES values sort in the same order as
1611
- # their raw encodings. - Counterexample: Encoding INT64 to a fixed-width STRING
1612
- # does *not* preserve sort order when dealing with negative numbers. INT64(1) >
1613
- # INT64(-1), but STRING("-00001") > STRING("00001). - The overall encoding chain
1614
- # has this property if *every* link does. * Self-delimiting: If we concatenate
1607
+ # which describes how to convert to/from the underlying data. Each encoding also
1608
+ # defines the following properties: * Order-preserving: Does the encoded value
1609
+ # sort consistently with the original typed value? Note that Bigtable will
1610
+ # always sort data based on the raw encoded value, *not* the decoded type. -
1611
+ # Example: BYTES values sort in the same order as their raw encodings. -
1612
+ # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
1613
+ # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
1614
+ # but STRING("-00001") > STRING("00001). * Self-delimiting: If we concatenate
1615
1615
  # two encoded values, can we always tell where the first one ends and the second
1616
1616
  # one begins? - Example: If we encode INT64s to fixed-width STRINGs, the first
1617
1617
  # value will always contain exactly N digits, possibly preceded by a sign. -
1618
1618
  # Counterexample: If we concatenate two UTF-8 encoded STRINGs, we have no way to
1619
- # tell where the first one ends. - The overall encoding chain has this property
1620
- # if *any* link does. * Compatibility: Which other systems have matching
1621
- # encoding schemes? For example, does this encoding have a GoogleSQL equivalent?
1622
- # HBase? Java?
1619
+ # tell where the first one ends. * Compatibility: Which other systems have
1620
+ # matching encoding schemes? For example, does this encoding have a GoogleSQL
1621
+ # equivalent? HBase? Java?
1623
1622
  # Corresponds to the JSON property `inputType`
1624
1623
  # @return [Google::Apis::BigtableadminV2::Type]
1625
1624
  attr_accessor :input_type
1626
1625
 
1626
+ # Computes the max of the input values. Allowed input: `Int64` State: same as
1627
+ # input
1628
+ # Corresponds to the JSON property `max`
1629
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateMax]
1630
+ attr_accessor :max
1631
+
1632
+ # Computes the min of the input values. Allowed input: `Int64` State: same as
1633
+ # input
1634
+ # Corresponds to the JSON property `min`
1635
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateMin]
1636
+ attr_accessor :min
1637
+
1627
1638
  # `Type` represents the type of data that is written to, read from, or stored in
1628
1639
  # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
1629
1640
  # familiarity and consistency across products and features. For compatibility
1630
1641
  # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
1631
- # which describes how to convert to/from the underlying data. This might involve
1632
- # composing a series of steps into an "encoding chain," for example to convert
1633
- # from INT64 -> STRING -> raw bytes. In most cases, a "link" in the encoding
1634
- # chain will be based an on existing GoogleSQL conversion function like `CAST`.
1635
- # Each link in the encoding chain also defines the following properties: *
1636
- # Natural sort: Does the encoded value sort consistently with the original typed
1637
- # value? Note that Bigtable will always sort data based on the raw encoded value,
1638
- # *not* the decoded type. - Example: BYTES values sort in the same order as
1639
- # their raw encodings. - Counterexample: Encoding INT64 to a fixed-width STRING
1640
- # does *not* preserve sort order when dealing with negative numbers. INT64(1) >
1641
- # INT64(-1), but STRING("-00001") > STRING("00001). - The overall encoding chain
1642
- # has this property if *every* link does. * Self-delimiting: If we concatenate
1642
+ # which describes how to convert to/from the underlying data. Each encoding also
1643
+ # defines the following properties: * Order-preserving: Does the encoded value
1644
+ # sort consistently with the original typed value? Note that Bigtable will
1645
+ # always sort data based on the raw encoded value, *not* the decoded type. -
1646
+ # Example: BYTES values sort in the same order as their raw encodings. -
1647
+ # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
1648
+ # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
1649
+ # but STRING("-00001") > STRING("00001). * Self-delimiting: If we concatenate
1643
1650
  # two encoded values, can we always tell where the first one ends and the second
1644
1651
  # one begins? - Example: If we encode INT64s to fixed-width STRINGs, the first
1645
1652
  # value will always contain exactly N digits, possibly preceded by a sign. -
1646
1653
  # Counterexample: If we concatenate two UTF-8 encoded STRINGs, we have no way to
1647
- # tell where the first one ends. - The overall encoding chain has this property
1648
- # if *any* link does. * Compatibility: Which other systems have matching
1649
- # encoding schemes? For example, does this encoding have a GoogleSQL equivalent?
1650
- # HBase? Java?
1654
+ # tell where the first one ends. * Compatibility: Which other systems have
1655
+ # matching encoding schemes? For example, does this encoding have a GoogleSQL
1656
+ # equivalent? HBase? Java?
1651
1657
  # Corresponds to the JSON property `stateType`
1652
1658
  # @return [Google::Apis::BigtableadminV2::Type]
1653
1659
  attr_accessor :state_type
@@ -1664,12 +1670,60 @@ module Google
1664
1670
 
1665
1671
  # Update properties of this object
1666
1672
  def update!(**args)
1673
+ @hllpp_unique_count = args[:hllpp_unique_count] if args.key?(:hllpp_unique_count)
1667
1674
  @input_type = args[:input_type] if args.key?(:input_type)
1675
+ @max = args[:max] if args.key?(:max)
1676
+ @min = args[:min] if args.key?(:min)
1668
1677
  @state_type = args[:state_type] if args.key?(:state_type)
1669
1678
  @sum = args[:sum] if args.key?(:sum)
1670
1679
  end
1671
1680
  end
1672
1681
 
1682
+ # Computes an approximate unique count over the input values. When using raw
1683
+ # data as input, be careful to use a consistent encoding. Otherwise the same
1684
+ # value encoded differently could count more than once, or two distinct values
1685
+ # could count as identical. Input: Any, or omit for Raw State: TBD Special state
1686
+ # conversions: `Int64` (the unique count estimate)
1687
+ class GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
1688
+ include Google::Apis::Core::Hashable
1689
+
1690
+ def initialize(**args)
1691
+ update!(**args)
1692
+ end
1693
+
1694
+ # Update properties of this object
1695
+ def update!(**args)
1696
+ end
1697
+ end
1698
+
1699
+ # Computes the max of the input values. Allowed input: `Int64` State: same as
1700
+ # input
1701
+ class GoogleBigtableAdminV2TypeAggregateMax
1702
+ include Google::Apis::Core::Hashable
1703
+
1704
+ def initialize(**args)
1705
+ update!(**args)
1706
+ end
1707
+
1708
+ # Update properties of this object
1709
+ def update!(**args)
1710
+ end
1711
+ end
1712
+
1713
+ # Computes the min of the input values. Allowed input: `Int64` State: same as
1714
+ # input
1715
+ class GoogleBigtableAdminV2TypeAggregateMin
1716
+ include Google::Apis::Core::Hashable
1717
+
1718
+ def initialize(**args)
1719
+ update!(**args)
1720
+ end
1721
+
1722
+ # Update properties of this object
1723
+ def update!(**args)
1724
+ end
1725
+ end
1726
+
1673
1727
  # Computes the sum of the input values. Allowed input: `Int64` State: same as
1674
1728
  # input
1675
1729
  class GoogleBigtableAdminV2TypeAggregateSum
@@ -1684,6 +1738,57 @@ module Google
1684
1738
  end
1685
1739
  end
1686
1740
 
1741
+ # An ordered list of elements of a given type. Values of type `Array` are stored
1742
+ # in `Value.array_value`.
1743
+ class GoogleBigtableAdminV2TypeArray
1744
+ include Google::Apis::Core::Hashable
1745
+
1746
+ # `Type` represents the type of data that is written to, read from, or stored in
1747
+ # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
1748
+ # familiarity and consistency across products and features. For compatibility
1749
+ # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
1750
+ # which describes how to convert to/from the underlying data. Each encoding also
1751
+ # defines the following properties: * Order-preserving: Does the encoded value
1752
+ # sort consistently with the original typed value? Note that Bigtable will
1753
+ # always sort data based on the raw encoded value, *not* the decoded type. -
1754
+ # Example: BYTES values sort in the same order as their raw encodings. -
1755
+ # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
1756
+ # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
1757
+ # but STRING("-00001") > STRING("00001). * Self-delimiting: If we concatenate
1758
+ # two encoded values, can we always tell where the first one ends and the second
1759
+ # one begins? - Example: If we encode INT64s to fixed-width STRINGs, the first
1760
+ # value will always contain exactly N digits, possibly preceded by a sign. -
1761
+ # Counterexample: If we concatenate two UTF-8 encoded STRINGs, we have no way to
1762
+ # tell where the first one ends. * Compatibility: Which other systems have
1763
+ # matching encoding schemes? For example, does this encoding have a GoogleSQL
1764
+ # equivalent? HBase? Java?
1765
+ # Corresponds to the JSON property `elementType`
1766
+ # @return [Google::Apis::BigtableadminV2::Type]
1767
+ attr_accessor :element_type
1768
+
1769
+ def initialize(**args)
1770
+ update!(**args)
1771
+ end
1772
+
1773
+ # Update properties of this object
1774
+ def update!(**args)
1775
+ @element_type = args[:element_type] if args.key?(:element_type)
1776
+ end
1777
+ end
1778
+
1779
+ # bool Values of type `Bool` are stored in `Value.bool_value`.
1780
+ class GoogleBigtableAdminV2TypeBool
1781
+ include Google::Apis::Core::Hashable
1782
+
1783
+ def initialize(**args)
1784
+ update!(**args)
1785
+ end
1786
+
1787
+ # Update properties of this object
1788
+ def update!(**args)
1789
+ end
1790
+ end
1791
+
1687
1792
  # Bytes Values of type `Bytes` are stored in `Value.bytes_value`.
1688
1793
  class GoogleBigtableAdminV2TypeBytes
1689
1794
  include Google::Apis::Core::Hashable
@@ -1707,7 +1812,7 @@ module Google
1707
1812
  class GoogleBigtableAdminV2TypeBytesEncoding
1708
1813
  include Google::Apis::Core::Hashable
1709
1814
 
1710
- # Leaves the value "as-is" * Natural sort? Yes * Self-delimiting? No *
1815
+ # Leaves the value "as-is" * Order-preserving? Yes * Self-delimiting? No *
1711
1816
  # Compatibility? N/A
1712
1817
  # Corresponds to the JSON property `raw`
1713
1818
  # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytesEncodingRaw]
@@ -1723,7 +1828,7 @@ module Google
1723
1828
  end
1724
1829
  end
1725
1830
 
1726
- # Leaves the value "as-is" * Natural sort? Yes * Self-delimiting? No *
1831
+ # Leaves the value "as-is" * Order-preserving? Yes * Self-delimiting? No *
1727
1832
  # Compatibility? N/A
1728
1833
  class GoogleBigtableAdminV2TypeBytesEncodingRaw
1729
1834
  include Google::Apis::Core::Hashable
@@ -1737,6 +1842,45 @@ module Google
1737
1842
  end
1738
1843
  end
1739
1844
 
1845
+ # Date Values of type `Date` are stored in `Value.date_value`.
1846
+ class GoogleBigtableAdminV2TypeDate
1847
+ include Google::Apis::Core::Hashable
1848
+
1849
+ def initialize(**args)
1850
+ update!(**args)
1851
+ end
1852
+
1853
+ # Update properties of this object
1854
+ def update!(**args)
1855
+ end
1856
+ end
1857
+
1858
+ # Float32 Values of type `Float32` are stored in `Value.float_value`.
1859
+ class GoogleBigtableAdminV2TypeFloat32
1860
+ include Google::Apis::Core::Hashable
1861
+
1862
+ def initialize(**args)
1863
+ update!(**args)
1864
+ end
1865
+
1866
+ # Update properties of this object
1867
+ def update!(**args)
1868
+ end
1869
+ end
1870
+
1871
+ # Float64 Values of type `Float64` are stored in `Value.float_value`.
1872
+ class GoogleBigtableAdminV2TypeFloat64
1873
+ include Google::Apis::Core::Hashable
1874
+
1875
+ def initialize(**args)
1876
+ update!(**args)
1877
+ end
1878
+
1879
+ # Update properties of this object
1880
+ def update!(**args)
1881
+ end
1882
+ end
1883
+
1740
1884
  # Int64 Values of type `Int64` are stored in `Value.int_value`.
1741
1885
  class GoogleBigtableAdminV2TypeInt64
1742
1886
  include Google::Apis::Core::Hashable
@@ -1761,9 +1905,9 @@ module Google
1761
1905
  include Google::Apis::Core::Hashable
1762
1906
 
1763
1907
  # Encodes the value as an 8-byte big endian twos complement `Bytes` value. *
1764
- # Natural sort? No (positive values only) * Self-delimiting? Yes * Compatibility?
1765
- # - BigQuery Federation `BINARY` encoding - HBase `Bytes.toBytes` - Java `
1766
- # ByteBuffer.putLong()` with `ByteOrder.BIG_ENDIAN`
1908
+ # Order-preserving? No (positive values only) * Self-delimiting? Yes *
1909
+ # Compatibility? - BigQuery Federation `BINARY` encoding - HBase `Bytes.toBytes`
1910
+ # - Java `ByteBuffer.putLong()` with `ByteOrder.BIG_ENDIAN`
1767
1911
  # Corresponds to the JSON property `bigEndianBytes`
1768
1912
  # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes]
1769
1913
  attr_accessor :big_endian_bytes
@@ -1779,9 +1923,9 @@ module Google
1779
1923
  end
1780
1924
 
1781
1925
  # Encodes the value as an 8-byte big endian twos complement `Bytes` value. *
1782
- # Natural sort? No (positive values only) * Self-delimiting? Yes * Compatibility?
1783
- # - BigQuery Federation `BINARY` encoding - HBase `Bytes.toBytes` - Java `
1784
- # ByteBuffer.putLong()` with `ByteOrder.BIG_ENDIAN`
1926
+ # Order-preserving? No (positive values only) * Self-delimiting? Yes *
1927
+ # Compatibility? - BigQuery Federation `BINARY` encoding - HBase `Bytes.toBytes`
1928
+ # - Java `ByteBuffer.putLong()` with `ByteOrder.BIG_ENDIAN`
1785
1929
  class GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes
1786
1930
  include Google::Apis::Core::Hashable
1787
1931
 
@@ -1800,6 +1944,205 @@ module Google
1800
1944
  end
1801
1945
  end
1802
1946
 
1947
+ # A mapping of keys to values of a given type. Values of type `Map` are stored
1948
+ # in a `Value.array_value` where each entry is another `Value.array_value` with
1949
+ # two elements (the key and the value, in that order). Normally encoded Map
1950
+ # values won't have repeated keys, however, clients are expected to handle the
1951
+ # case in which they do. If the same key appears multiple times, the _last_
1952
+ # value takes precedence.
1953
+ class GoogleBigtableAdminV2TypeMap
1954
+ include Google::Apis::Core::Hashable
1955
+
1956
+ # `Type` represents the type of data that is written to, read from, or stored in
1957
+ # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
1958
+ # familiarity and consistency across products and features. For compatibility
1959
+ # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
1960
+ # which describes how to convert to/from the underlying data. Each encoding also
1961
+ # defines the following properties: * Order-preserving: Does the encoded value
1962
+ # sort consistently with the original typed value? Note that Bigtable will
1963
+ # always sort data based on the raw encoded value, *not* the decoded type. -
1964
+ # Example: BYTES values sort in the same order as their raw encodings. -
1965
+ # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
1966
+ # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
1967
+ # but STRING("-00001") > STRING("00001). * Self-delimiting: If we concatenate
1968
+ # two encoded values, can we always tell where the first one ends and the second
1969
+ # one begins? - Example: If we encode INT64s to fixed-width STRINGs, the first
1970
+ # value will always contain exactly N digits, possibly preceded by a sign. -
1971
+ # Counterexample: If we concatenate two UTF-8 encoded STRINGs, we have no way to
1972
+ # tell where the first one ends. * Compatibility: Which other systems have
1973
+ # matching encoding schemes? For example, does this encoding have a GoogleSQL
1974
+ # equivalent? HBase? Java?
1975
+ # Corresponds to the JSON property `keyType`
1976
+ # @return [Google::Apis::BigtableadminV2::Type]
1977
+ attr_accessor :key_type
1978
+
1979
+ # `Type` represents the type of data that is written to, read from, or stored in
1980
+ # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
1981
+ # familiarity and consistency across products and features. For compatibility
1982
+ # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
1983
+ # which describes how to convert to/from the underlying data. Each encoding also
1984
+ # defines the following properties: * Order-preserving: Does the encoded value
1985
+ # sort consistently with the original typed value? Note that Bigtable will
1986
+ # always sort data based on the raw encoded value, *not* the decoded type. -
1987
+ # Example: BYTES values sort in the same order as their raw encodings. -
1988
+ # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
1989
+ # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
1990
+ # but STRING("-00001") > STRING("00001). * Self-delimiting: If we concatenate
1991
+ # two encoded values, can we always tell where the first one ends and the second
1992
+ # one begins? - Example: If we encode INT64s to fixed-width STRINGs, the first
1993
+ # value will always contain exactly N digits, possibly preceded by a sign. -
1994
+ # Counterexample: If we concatenate two UTF-8 encoded STRINGs, we have no way to
1995
+ # tell where the first one ends. * Compatibility: Which other systems have
1996
+ # matching encoding schemes? For example, does this encoding have a GoogleSQL
1997
+ # equivalent? HBase? Java?
1998
+ # Corresponds to the JSON property `valueType`
1999
+ # @return [Google::Apis::BigtableadminV2::Type]
2000
+ attr_accessor :value_type
2001
+
2002
+ def initialize(**args)
2003
+ update!(**args)
2004
+ end
2005
+
2006
+ # Update properties of this object
2007
+ def update!(**args)
2008
+ @key_type = args[:key_type] if args.key?(:key_type)
2009
+ @value_type = args[:value_type] if args.key?(:value_type)
2010
+ end
2011
+ end
2012
+
2013
+ # String Values of type `String` are stored in `Value.string_value`.
2014
+ class GoogleBigtableAdminV2TypeString
2015
+ include Google::Apis::Core::Hashable
2016
+
2017
+ # Rules used to convert to/from lower level types.
2018
+ # Corresponds to the JSON property `encoding`
2019
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStringEncoding]
2020
+ attr_accessor :encoding
2021
+
2022
+ def initialize(**args)
2023
+ update!(**args)
2024
+ end
2025
+
2026
+ # Update properties of this object
2027
+ def update!(**args)
2028
+ @encoding = args[:encoding] if args.key?(:encoding)
2029
+ end
2030
+ end
2031
+
2032
+ # Rules used to convert to/from lower level types.
2033
+ class GoogleBigtableAdminV2TypeStringEncoding
2034
+ include Google::Apis::Core::Hashable
2035
+
2036
+ # UTF-8 encoding * Order-preserving? Yes (code point order) * Self-delimiting?
2037
+ # No * Compatibility? - BigQuery Federation `TEXT` encoding - HBase `Bytes.
2038
+ # toBytes` - Java `String#getBytes(StandardCharsets.UTF_8)`
2039
+ # Corresponds to the JSON property `utf8Bytes`
2040
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes]
2041
+ attr_accessor :utf8_bytes
2042
+
2043
+ def initialize(**args)
2044
+ update!(**args)
2045
+ end
2046
+
2047
+ # Update properties of this object
2048
+ def update!(**args)
2049
+ @utf8_bytes = args[:utf8_bytes] if args.key?(:utf8_bytes)
2050
+ end
2051
+ end
2052
+
2053
+ # UTF-8 encoding * Order-preserving? Yes (code point order) * Self-delimiting?
2054
+ # No * Compatibility? - BigQuery Federation `TEXT` encoding - HBase `Bytes.
2055
+ # toBytes` - Java `String#getBytes(StandardCharsets.UTF_8)`
2056
+ class GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes
2057
+ include Google::Apis::Core::Hashable
2058
+
2059
+ def initialize(**args)
2060
+ update!(**args)
2061
+ end
2062
+
2063
+ # Update properties of this object
2064
+ def update!(**args)
2065
+ end
2066
+ end
2067
+
2068
+ # A structured data value, consisting of fields which map to dynamically typed
2069
+ # values. Values of type `Struct` are stored in `Value.array_value` where
2070
+ # entries are in the same order and number as `field_types`.
2071
+ class GoogleBigtableAdminV2TypeStruct
2072
+ include Google::Apis::Core::Hashable
2073
+
2074
+ # The names and types of the fields in this struct.
2075
+ # Corresponds to the JSON property `fields`
2076
+ # @return [Array<Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStructField>]
2077
+ attr_accessor :fields
2078
+
2079
+ def initialize(**args)
2080
+ update!(**args)
2081
+ end
2082
+
2083
+ # Update properties of this object
2084
+ def update!(**args)
2085
+ @fields = args[:fields] if args.key?(:fields)
2086
+ end
2087
+ end
2088
+
2089
+ # A struct field and its type.
2090
+ class GoogleBigtableAdminV2TypeStructField
2091
+ include Google::Apis::Core::Hashable
2092
+
2093
+ # The field name (optional). Fields without a `field_name` are considered
2094
+ # anonymous and cannot be referenced by name.
2095
+ # Corresponds to the JSON property `fieldName`
2096
+ # @return [String]
2097
+ attr_accessor :field_name
2098
+
2099
+ # `Type` represents the type of data that is written to, read from, or stored in
2100
+ # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
2101
+ # familiarity and consistency across products and features. For compatibility
2102
+ # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
2103
+ # which describes how to convert to/from the underlying data. Each encoding also
2104
+ # defines the following properties: * Order-preserving: Does the encoded value
2105
+ # sort consistently with the original typed value? Note that Bigtable will
2106
+ # always sort data based on the raw encoded value, *not* the decoded type. -
2107
+ # Example: BYTES values sort in the same order as their raw encodings. -
2108
+ # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
2109
+ # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
2110
+ # but STRING("-00001") > STRING("00001). * Self-delimiting: If we concatenate
2111
+ # two encoded values, can we always tell where the first one ends and the second
2112
+ # one begins? - Example: If we encode INT64s to fixed-width STRINGs, the first
2113
+ # value will always contain exactly N digits, possibly preceded by a sign. -
2114
+ # Counterexample: If we concatenate two UTF-8 encoded STRINGs, we have no way to
2115
+ # tell where the first one ends. * Compatibility: Which other systems have
2116
+ # matching encoding schemes? For example, does this encoding have a GoogleSQL
2117
+ # equivalent? HBase? Java?
2118
+ # Corresponds to the JSON property `type`
2119
+ # @return [Google::Apis::BigtableadminV2::Type]
2120
+ attr_accessor :type
2121
+
2122
+ def initialize(**args)
2123
+ update!(**args)
2124
+ end
2125
+
2126
+ # Update properties of this object
2127
+ def update!(**args)
2128
+ @field_name = args[:field_name] if args.key?(:field_name)
2129
+ @type = args[:type] if args.key?(:type)
2130
+ end
2131
+ end
2132
+
2133
+ # Timestamp Values of type `Timestamp` are stored in `Value.timestamp_value`.
2134
+ class GoogleBigtableAdminV2TypeTimestamp
2135
+ include Google::Apis::Core::Hashable
2136
+
2137
+ def initialize(**args)
2138
+ update!(**args)
2139
+ end
2140
+
2141
+ # Update properties of this object
2142
+ def update!(**args)
2143
+ end
2144
+ end
2145
+
1803
2146
  # A tablet is a defined by a start and end key and is explained in https://cloud.
1804
2147
  # google.com/bigtable/docs/overview#architecture and https://cloud.google.com/
1805
2148
  # bigtable/docs/performance#optimization. A Hot tablet is a tablet that exhibits
@@ -3163,26 +3506,21 @@ module Google
3163
3506
  # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
3164
3507
  # familiarity and consistency across products and features. For compatibility
3165
3508
  # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
3166
- # which describes how to convert to/from the underlying data. This might involve
3167
- # composing a series of steps into an "encoding chain," for example to convert
3168
- # from INT64 -> STRING -> raw bytes. In most cases, a "link" in the encoding
3169
- # chain will be based an on existing GoogleSQL conversion function like `CAST`.
3170
- # Each link in the encoding chain also defines the following properties: *
3171
- # Natural sort: Does the encoded value sort consistently with the original typed
3172
- # value? Note that Bigtable will always sort data based on the raw encoded value,
3173
- # *not* the decoded type. - Example: BYTES values sort in the same order as
3174
- # their raw encodings. - Counterexample: Encoding INT64 to a fixed-width STRING
3175
- # does *not* preserve sort order when dealing with negative numbers. INT64(1) >
3176
- # INT64(-1), but STRING("-00001") > STRING("00001). - The overall encoding chain
3177
- # has this property if *every* link does. * Self-delimiting: If we concatenate
3509
+ # which describes how to convert to/from the underlying data. Each encoding also
3510
+ # defines the following properties: * Order-preserving: Does the encoded value
3511
+ # sort consistently with the original typed value? Note that Bigtable will
3512
+ # always sort data based on the raw encoded value, *not* the decoded type. -
3513
+ # Example: BYTES values sort in the same order as their raw encodings. -
3514
+ # Counterexample: Encoding INT64 as a fixed-width decimal string does *not*
3515
+ # preserve sort order when dealing with negative numbers. INT64(1) > INT64(-1),
3516
+ # but STRING("-00001") > STRING("00001). * Self-delimiting: If we concatenate
3178
3517
  # two encoded values, can we always tell where the first one ends and the second
3179
3518
  # one begins? - Example: If we encode INT64s to fixed-width STRINGs, the first
3180
3519
  # value will always contain exactly N digits, possibly preceded by a sign. -
3181
3520
  # Counterexample: If we concatenate two UTF-8 encoded STRINGs, we have no way to
3182
- # tell where the first one ends. - The overall encoding chain has this property
3183
- # if *any* link does. * Compatibility: Which other systems have matching
3184
- # encoding schemes? For example, does this encoding have a GoogleSQL equivalent?
3185
- # HBase? Java?
3521
+ # tell where the first one ends. * Compatibility: Which other systems have
3522
+ # matching encoding schemes? For example, does this encoding have a GoogleSQL
3523
+ # equivalent? HBase? Java?
3186
3524
  class Type
3187
3525
  include Google::Apis::Core::Hashable
3188
3526
 
@@ -3194,16 +3532,69 @@ module Google
3194
3532
  # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregate]
3195
3533
  attr_accessor :aggregate_type
3196
3534
 
3535
+ # An ordered list of elements of a given type. Values of type `Array` are stored
3536
+ # in `Value.array_value`.
3537
+ # Corresponds to the JSON property `arrayType`
3538
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeArray]
3539
+ attr_accessor :array_type
3540
+
3541
+ # bool Values of type `Bool` are stored in `Value.bool_value`.
3542
+ # Corresponds to the JSON property `boolType`
3543
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBool]
3544
+ attr_accessor :bool_type
3545
+
3197
3546
  # Bytes Values of type `Bytes` are stored in `Value.bytes_value`.
3198
3547
  # Corresponds to the JSON property `bytesType`
3199
3548
  # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytes]
3200
3549
  attr_accessor :bytes_type
3201
3550
 
3551
+ # Date Values of type `Date` are stored in `Value.date_value`.
3552
+ # Corresponds to the JSON property `dateType`
3553
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeDate]
3554
+ attr_accessor :date_type
3555
+
3556
+ # Float32 Values of type `Float32` are stored in `Value.float_value`.
3557
+ # Corresponds to the JSON property `float32Type`
3558
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeFloat32]
3559
+ attr_accessor :float32_type
3560
+
3561
+ # Float64 Values of type `Float64` are stored in `Value.float_value`.
3562
+ # Corresponds to the JSON property `float64Type`
3563
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeFloat64]
3564
+ attr_accessor :float64_type
3565
+
3202
3566
  # Int64 Values of type `Int64` are stored in `Value.int_value`.
3203
3567
  # Corresponds to the JSON property `int64Type`
3204
3568
  # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64]
3205
3569
  attr_accessor :int64_type
3206
3570
 
3571
+ # A mapping of keys to values of a given type. Values of type `Map` are stored
3572
+ # in a `Value.array_value` where each entry is another `Value.array_value` with
3573
+ # two elements (the key and the value, in that order). Normally encoded Map
3574
+ # values won't have repeated keys, however, clients are expected to handle the
3575
+ # case in which they do. If the same key appears multiple times, the _last_
3576
+ # value takes precedence.
3577
+ # Corresponds to the JSON property `mapType`
3578
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeMap]
3579
+ attr_accessor :map_type
3580
+
3581
+ # String Values of type `String` are stored in `Value.string_value`.
3582
+ # Corresponds to the JSON property `stringType`
3583
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeString]
3584
+ attr_accessor :string_type
3585
+
3586
+ # A structured data value, consisting of fields which map to dynamically typed
3587
+ # values. Values of type `Struct` are stored in `Value.array_value` where
3588
+ # entries are in the same order and number as `field_types`.
3589
+ # Corresponds to the JSON property `structType`
3590
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStruct]
3591
+ attr_accessor :struct_type
3592
+
3593
+ # Timestamp Values of type `Timestamp` are stored in `Value.timestamp_value`.
3594
+ # Corresponds to the JSON property `timestampType`
3595
+ # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeTimestamp]
3596
+ attr_accessor :timestamp_type
3597
+
3207
3598
  def initialize(**args)
3208
3599
  update!(**args)
3209
3600
  end
@@ -3211,8 +3602,17 @@ module Google
3211
3602
  # Update properties of this object
3212
3603
  def update!(**args)
3213
3604
  @aggregate_type = args[:aggregate_type] if args.key?(:aggregate_type)
3605
+ @array_type = args[:array_type] if args.key?(:array_type)
3606
+ @bool_type = args[:bool_type] if args.key?(:bool_type)
3214
3607
  @bytes_type = args[:bytes_type] if args.key?(:bytes_type)
3608
+ @date_type = args[:date_type] if args.key?(:date_type)
3609
+ @float32_type = args[:float32_type] if args.key?(:float32_type)
3610
+ @float64_type = args[:float64_type] if args.key?(:float64_type)
3215
3611
  @int64_type = args[:int64_type] if args.key?(:int64_type)
3612
+ @map_type = args[:map_type] if args.key?(:map_type)
3613
+ @string_type = args[:string_type] if args.key?(:string_type)
3614
+ @struct_type = args[:struct_type] if args.key?(:struct_type)
3615
+ @timestamp_type = args[:timestamp_type] if args.key?(:timestamp_type)
3216
3616
  end
3217
3617
  end
3218
3618
 
@@ -16,13 +16,13 @@ module Google
16
16
  module Apis
17
17
  module BigtableadminV2
18
18
  # Version of the google-apis-bigtableadmin_v2 gem
19
- GEM_VERSION = "0.57.0"
19
+ GEM_VERSION = "0.58.0"
20
20
 
21
21
  # Version of the code generator used to generate this client
22
22
  GENERATOR_VERSION = "0.15.0"
23
23
 
24
24
  # Revision of the discovery document this client was generated from
25
- REVISION = "20240604"
25
+ REVISION = "20240703"
26
26
  end
27
27
  end
28
28
  end
@@ -286,12 +286,42 @@ module Google
286
286
  include Google::Apis::Core::JsonObjectSupport
287
287
  end
288
288
 
289
+ class GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
290
+ class Representation < Google::Apis::Core::JsonRepresentation; end
291
+
292
+ include Google::Apis::Core::JsonObjectSupport
293
+ end
294
+
295
+ class GoogleBigtableAdminV2TypeAggregateMax
296
+ class Representation < Google::Apis::Core::JsonRepresentation; end
297
+
298
+ include Google::Apis::Core::JsonObjectSupport
299
+ end
300
+
301
+ class GoogleBigtableAdminV2TypeAggregateMin
302
+ class Representation < Google::Apis::Core::JsonRepresentation; end
303
+
304
+ include Google::Apis::Core::JsonObjectSupport
305
+ end
306
+
289
307
  class GoogleBigtableAdminV2TypeAggregateSum
290
308
  class Representation < Google::Apis::Core::JsonRepresentation; end
291
309
 
292
310
  include Google::Apis::Core::JsonObjectSupport
293
311
  end
294
312
 
313
+ class GoogleBigtableAdminV2TypeArray
314
+ class Representation < Google::Apis::Core::JsonRepresentation; end
315
+
316
+ include Google::Apis::Core::JsonObjectSupport
317
+ end
318
+
319
+ class GoogleBigtableAdminV2TypeBool
320
+ class Representation < Google::Apis::Core::JsonRepresentation; end
321
+
322
+ include Google::Apis::Core::JsonObjectSupport
323
+ end
324
+
295
325
  class GoogleBigtableAdminV2TypeBytes
296
326
  class Representation < Google::Apis::Core::JsonRepresentation; end
297
327
 
@@ -310,6 +340,24 @@ module Google
310
340
  include Google::Apis::Core::JsonObjectSupport
311
341
  end
312
342
 
343
+ class GoogleBigtableAdminV2TypeDate
344
+ class Representation < Google::Apis::Core::JsonRepresentation; end
345
+
346
+ include Google::Apis::Core::JsonObjectSupport
347
+ end
348
+
349
+ class GoogleBigtableAdminV2TypeFloat32
350
+ class Representation < Google::Apis::Core::JsonRepresentation; end
351
+
352
+ include Google::Apis::Core::JsonObjectSupport
353
+ end
354
+
355
+ class GoogleBigtableAdminV2TypeFloat64
356
+ class Representation < Google::Apis::Core::JsonRepresentation; end
357
+
358
+ include Google::Apis::Core::JsonObjectSupport
359
+ end
360
+
313
361
  class GoogleBigtableAdminV2TypeInt64
314
362
  class Representation < Google::Apis::Core::JsonRepresentation; end
315
363
 
@@ -328,6 +376,48 @@ module Google
328
376
  include Google::Apis::Core::JsonObjectSupport
329
377
  end
330
378
 
379
+ class GoogleBigtableAdminV2TypeMap
380
+ class Representation < Google::Apis::Core::JsonRepresentation; end
381
+
382
+ include Google::Apis::Core::JsonObjectSupport
383
+ end
384
+
385
+ class GoogleBigtableAdminV2TypeString
386
+ class Representation < Google::Apis::Core::JsonRepresentation; end
387
+
388
+ include Google::Apis::Core::JsonObjectSupport
389
+ end
390
+
391
+ class GoogleBigtableAdminV2TypeStringEncoding
392
+ class Representation < Google::Apis::Core::JsonRepresentation; end
393
+
394
+ include Google::Apis::Core::JsonObjectSupport
395
+ end
396
+
397
+ class GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes
398
+ class Representation < Google::Apis::Core::JsonRepresentation; end
399
+
400
+ include Google::Apis::Core::JsonObjectSupport
401
+ end
402
+
403
+ class GoogleBigtableAdminV2TypeStruct
404
+ class Representation < Google::Apis::Core::JsonRepresentation; end
405
+
406
+ include Google::Apis::Core::JsonObjectSupport
407
+ end
408
+
409
+ class GoogleBigtableAdminV2TypeStructField
410
+ class Representation < Google::Apis::Core::JsonRepresentation; end
411
+
412
+ include Google::Apis::Core::JsonObjectSupport
413
+ end
414
+
415
+ class GoogleBigtableAdminV2TypeTimestamp
416
+ class Representation < Google::Apis::Core::JsonRepresentation; end
417
+
418
+ include Google::Apis::Core::JsonObjectSupport
419
+ end
420
+
331
421
  class HotTablet
332
422
  class Representation < Google::Apis::Core::JsonRepresentation; end
333
423
 
@@ -1024,8 +1114,14 @@ module Google
1024
1114
  class GoogleBigtableAdminV2TypeAggregate
1025
1115
  # @private
1026
1116
  class Representation < Google::Apis::Core::JsonRepresentation
1117
+ property :hllpp_unique_count, as: 'hllppUniqueCount', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount::Representation
1118
+
1027
1119
  property :input_type, as: 'inputType', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
1028
1120
 
1121
+ property :max, as: 'max', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateMax, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateMax::Representation
1122
+
1123
+ property :min, as: 'min', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateMin, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateMin::Representation
1124
+
1029
1125
  property :state_type, as: 'stateType', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
1030
1126
 
1031
1127
  property :sum, as: 'sum', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateSum, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateSum::Representation
@@ -1033,12 +1129,44 @@ module Google
1033
1129
  end
1034
1130
  end
1035
1131
 
1132
+ class GoogleBigtableAdminV2TypeAggregateHyperLogLogPlusPlusUniqueCount
1133
+ # @private
1134
+ class Representation < Google::Apis::Core::JsonRepresentation
1135
+ end
1136
+ end
1137
+
1138
+ class GoogleBigtableAdminV2TypeAggregateMax
1139
+ # @private
1140
+ class Representation < Google::Apis::Core::JsonRepresentation
1141
+ end
1142
+ end
1143
+
1144
+ class GoogleBigtableAdminV2TypeAggregateMin
1145
+ # @private
1146
+ class Representation < Google::Apis::Core::JsonRepresentation
1147
+ end
1148
+ end
1149
+
1036
1150
  class GoogleBigtableAdminV2TypeAggregateSum
1037
1151
  # @private
1038
1152
  class Representation < Google::Apis::Core::JsonRepresentation
1039
1153
  end
1040
1154
  end
1041
1155
 
1156
+ class GoogleBigtableAdminV2TypeArray
1157
+ # @private
1158
+ class Representation < Google::Apis::Core::JsonRepresentation
1159
+ property :element_type, as: 'elementType', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
1160
+
1161
+ end
1162
+ end
1163
+
1164
+ class GoogleBigtableAdminV2TypeBool
1165
+ # @private
1166
+ class Representation < Google::Apis::Core::JsonRepresentation
1167
+ end
1168
+ end
1169
+
1042
1170
  class GoogleBigtableAdminV2TypeBytes
1043
1171
  # @private
1044
1172
  class Representation < Google::Apis::Core::JsonRepresentation
@@ -1061,6 +1189,24 @@ module Google
1061
1189
  end
1062
1190
  end
1063
1191
 
1192
+ class GoogleBigtableAdminV2TypeDate
1193
+ # @private
1194
+ class Representation < Google::Apis::Core::JsonRepresentation
1195
+ end
1196
+ end
1197
+
1198
+ class GoogleBigtableAdminV2TypeFloat32
1199
+ # @private
1200
+ class Representation < Google::Apis::Core::JsonRepresentation
1201
+ end
1202
+ end
1203
+
1204
+ class GoogleBigtableAdminV2TypeFloat64
1205
+ # @private
1206
+ class Representation < Google::Apis::Core::JsonRepresentation
1207
+ end
1208
+ end
1209
+
1064
1210
  class GoogleBigtableAdminV2TypeInt64
1065
1211
  # @private
1066
1212
  class Representation < Google::Apis::Core::JsonRepresentation
@@ -1085,6 +1231,61 @@ module Google
1085
1231
  end
1086
1232
  end
1087
1233
 
1234
+ class GoogleBigtableAdminV2TypeMap
1235
+ # @private
1236
+ class Representation < Google::Apis::Core::JsonRepresentation
1237
+ property :key_type, as: 'keyType', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
1238
+
1239
+ property :value_type, as: 'valueType', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
1240
+
1241
+ end
1242
+ end
1243
+
1244
+ class GoogleBigtableAdminV2TypeString
1245
+ # @private
1246
+ class Representation < Google::Apis::Core::JsonRepresentation
1247
+ property :encoding, as: 'encoding', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStringEncoding, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStringEncoding::Representation
1248
+
1249
+ end
1250
+ end
1251
+
1252
+ class GoogleBigtableAdminV2TypeStringEncoding
1253
+ # @private
1254
+ class Representation < Google::Apis::Core::JsonRepresentation
1255
+ property :utf8_bytes, as: 'utf8Bytes', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes::Representation
1256
+
1257
+ end
1258
+ end
1259
+
1260
+ class GoogleBigtableAdminV2TypeStringEncodingUtf8Bytes
1261
+ # @private
1262
+ class Representation < Google::Apis::Core::JsonRepresentation
1263
+ end
1264
+ end
1265
+
1266
+ class GoogleBigtableAdminV2TypeStruct
1267
+ # @private
1268
+ class Representation < Google::Apis::Core::JsonRepresentation
1269
+ collection :fields, as: 'fields', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStructField, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStructField::Representation
1270
+
1271
+ end
1272
+ end
1273
+
1274
+ class GoogleBigtableAdminV2TypeStructField
1275
+ # @private
1276
+ class Representation < Google::Apis::Core::JsonRepresentation
1277
+ property :field_name, as: 'fieldName'
1278
+ property :type, as: 'type', class: Google::Apis::BigtableadminV2::Type, decorator: Google::Apis::BigtableadminV2::Type::Representation
1279
+
1280
+ end
1281
+ end
1282
+
1283
+ class GoogleBigtableAdminV2TypeTimestamp
1284
+ # @private
1285
+ class Representation < Google::Apis::Core::JsonRepresentation
1286
+ end
1287
+ end
1288
+
1088
1289
  class HotTablet
1089
1290
  # @private
1090
1291
  class Representation < Google::Apis::Core::JsonRepresentation
@@ -1449,10 +1650,28 @@ module Google
1449
1650
  class Representation < Google::Apis::Core::JsonRepresentation
1450
1651
  property :aggregate_type, as: 'aggregateType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregate, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregate::Representation
1451
1652
 
1653
+ property :array_type, as: 'arrayType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeArray, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeArray::Representation
1654
+
1655
+ property :bool_type, as: 'boolType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBool, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBool::Representation
1656
+
1452
1657
  property :bytes_type, as: 'bytesType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytes, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytes::Representation
1453
1658
 
1659
+ property :date_type, as: 'dateType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeDate, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeDate::Representation
1660
+
1661
+ property :float32_type, as: 'float32Type', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeFloat32, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeFloat32::Representation
1662
+
1663
+ property :float64_type, as: 'float64Type', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeFloat64, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeFloat64::Representation
1664
+
1454
1665
  property :int64_type, as: 'int64Type', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64::Representation
1455
1666
 
1667
+ property :map_type, as: 'mapType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeMap, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeMap::Representation
1668
+
1669
+ property :string_type, as: 'stringType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeString, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeString::Representation
1670
+
1671
+ property :struct_type, as: 'structType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStruct, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeStruct::Representation
1672
+
1673
+ property :timestamp_type, as: 'timestampType', class: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeTimestamp, decorator: Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeTimestamp::Representation
1674
+
1456
1675
  end
1457
1676
  end
1458
1677
 
@@ -856,7 +856,7 @@ module Google
856
856
  # located in the destination instance and project.
857
857
  # @param [String] parent
858
858
  # Required. The name of the destination cluster that will contain the backup
859
- # copy. The cluster must already exists. Values are of the form: `projects/`
859
+ # copy. The cluster must already exist. Values are of the form: `projects/`
860
860
  # project`/instances/`instance`/clusters/`cluster``.
861
861
  # @param [Google::Apis::BigtableadminV2::CopyBackupRequest] copy_backup_request_object
862
862
  # @param [String] fields
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: google-apis-bigtableadmin_v2
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.57.0
4
+ version: 0.58.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Google LLC
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2024-06-16 00:00:00.000000000 Z
11
+ date: 2024-07-25 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: google-apis-core
@@ -58,7 +58,7 @@ licenses:
58
58
  metadata:
59
59
  bug_tracker_uri: https://github.com/googleapis/google-api-ruby-client/issues
60
60
  changelog_uri: https://github.com/googleapis/google-api-ruby-client/tree/main/generated/google-apis-bigtableadmin_v2/CHANGELOG.md
61
- documentation_uri: https://googleapis.dev/ruby/google-apis-bigtableadmin_v2/v0.57.0
61
+ documentation_uri: https://googleapis.dev/ruby/google-apis-bigtableadmin_v2/v0.58.0
62
62
  source_code_uri: https://github.com/googleapis/google-api-ruby-client/tree/main/generated/google-apis-bigtableadmin_v2
63
63
  post_install_message:
64
64
  rdoc_options: []