google-apis-bigtableadmin_v2 0.49.0 → 0.51.0

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

@@ -27,6 +27,19 @@ module Google
       class AppProfile
         include Google::Apis::Core::Hashable
       
+        # Data Boost is a serverless compute capability that lets you run high-
+        # throughput read jobs on your Bigtable data, without impacting the performance
+        # of the clusters that handle your application traffic. Currently, Data Boost
+        # exclusively supports read-only use-cases with single-cluster routing. Data
+        # Boost reads are only guaranteed to see the results of writes that were written
+        # at least 30 minutes ago. This means newly written values may not become
+        # visible for up to 30m, and also means that old values may remain visible for
+        # up to 30m after being deleted or overwritten. To mitigate the staleness of the
+        # data, users may either wait 30m, or use CheckConsistency.
+        # Corresponds to the JSON property `dataBoostIsolationReadOnly`
+        # @return [Google::Apis::BigtableadminV2::DataBoostIsolationReadOnly]
+        attr_accessor :data_boost_isolation_read_only
+      
         # Long form description of the use case for this AppProfile.
         # Corresponds to the JSON property `description`
         # @return [String]
@@ -82,6 +95,7 @@ module Google
       
         # Update properties of this object
         def update!(**args)
+          @data_boost_isolation_read_only = args[:data_boost_isolation_read_only] if args.key?(:data_boost_isolation_read_only)
           @description = args[:description] if args.key?(:description)
           @etag = args[:etag] if args.key?(:etag)
           @multi_cluster_routing_use_any = args[:multi_cluster_routing_use_any] if args.key?(:multi_cluster_routing_use_any)
@@ -163,6 +177,48 @@ module Google
         end
       end
       
+      # Placeholder for admin API work while we work out the internals.
+      class AuthorizedView
+        include Google::Apis::Core::Hashable
+      
+        # Set to true to make the AuthorizedView protected against deletion. The parent
+        # Table and containing Instance cannot be deleted if an AuthorizedView has this
+        # bit set.
+        # Corresponds to the JSON property `deletionProtection`
+        # @return [Boolean]
+        attr_accessor :deletion_protection
+        alias_method :deletion_protection?, :deletion_protection
+      
+        # The etag for this AuthorizedView. If this is provided on update, it must match
+        # the server's etag. The server returns ABORTED error on a mismatched etag.
+        # Corresponds to the JSON property `etag`
+        # @return [String]
+        attr_accessor :etag
+      
+        # Identifier. The name of this AuthorizedView. Values are of the form `projects/`
+        # project`/instances/`instance`/tables/`table`/authorizedViews/`authorized_view``
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # Defines a simple AuthorizedView that is a subset of the underlying Table.
+        # Corresponds to the JSON property `subsetView`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2AuthorizedViewSubsetView]
+        attr_accessor :subset_view
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @deletion_protection = args[:deletion_protection] if args.key?(:deletion_protection)
+          @etag = args[:etag] if args.key?(:etag)
+          @name = args[:name] if args.key?(:name)
+          @subset_view = args[:subset_view] if args.key?(:subset_view)
+        end
+      end
+      
       # Defines an automated backup policy for a table
       class AutomatedBackupPolicy
         include Google::Apis::Core::Hashable
@@ -510,6 +566,18 @@ module Google
         # @return [String]
         attr_accessor :consistency_token
       
+        # Checks that all writes before the consistency token was generated in the same
+        # cluster are readable by Databoost.
+        # Corresponds to the JSON property `dataBoostReadLocalWrites`
+        # @return [Google::Apis::BigtableadminV2::DataBoostReadLocalWrites]
+        attr_accessor :data_boost_read_local_writes
+      
+        # Checks that all writes before the consistency token was generated are
+        # replicated in every cluster and readable.
+        # Corresponds to the JSON property `standardReadRemoteWrites`
+        # @return [Google::Apis::BigtableadminV2::StandardReadRemoteWrites]
+        attr_accessor :standard_read_remote_writes
+      
         def initialize(**args)
            update!(**args)
         end
@@ -517,6 +585,8 @@ module Google
         # Update properties of this object
         def update!(**args)
           @consistency_token = args[:consistency_token] if args.key?(:consistency_token)
+          @data_boost_read_local_writes = args[:data_boost_read_local_writes] if args.key?(:data_boost_read_local_writes)
+          @standard_read_remote_writes = args[:standard_read_remote_writes] if args.key?(:standard_read_remote_writes)
         end
       end
       
@@ -695,6 +765,34 @@ module Google
         # @return [Google::Apis::BigtableadminV2::ColumnFamilyStats]
         attr_accessor :stats
       
+        # `Type` represents the type of data that is written to, read from, or stored in
+        # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
+        # familiarity and consistency across products and features. For compatibility
+        # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
+        # which describes how to convert to/from the underlying data. This might involve
+        # composing a series of steps into an "encoding chain," for example to convert
+        # from INT64 -> STRING -> raw bytes. In most cases, a "link" in the encoding
+        # chain will be based an on existing GoogleSQL conversion function like `CAST`.
+        # Each link in the encoding chain also defines the following properties: *
+        # Natural sort: Does the encoded value sort consistently with the original typed
+        # value? Note that Bigtable will always sort data based on the raw encoded value,
+        # *not* the decoded type. - Example: STRING values sort in the same order as
+        # their UTF-8 encodings. - Counterexample: Encoding INT64 to a fixed-width
+        # STRING does *not* preserve sort order when dealing with negative numbers.
+        # INT64(1) > INT64(-1), but STRING("-00001") > STRING("00001). - The overall
+        # encoding chain sorts naturally if *every* link does. * Self-delimiting: If we
+        # concatenate two encoded values, can we always tell where the first one ends
+        # and the second one begins? - Example: If we encode INT64s to fixed-width
+        # STRINGs, the first value will always contain exactly N digits, possibly
+        # preceded by a sign. - Counterexample: If we concatenate two UTF-8 encoded
+        # STRINGs, we have no way to tell where the first one ends. - The overall
+        # encoding chain is self-delimiting if *any* link is. * Compatibility: Which
+        # other systems have matching encoding schemes? For example, does this encoding
+        # have a GoogleSQL equivalent? HBase? Java?
+        # Corresponds to the JSON property `valueType`
+        # @return [Google::Apis::BigtableadminV2::Type]
+        attr_accessor :value_type
+      
         def initialize(**args)
            update!(**args)
         end
@@ -703,6 +801,7 @@ module Google
         def update!(**args)
           @gc_rule = args[:gc_rule] if args.key?(:gc_rule)
           @stats = args[:stats] if args.key?(:stats)
+          @value_type = args[:value_type] if args.key?(:value_type)
         end
       end
       
@@ -829,6 +928,72 @@ module Google
         end
       end
       
+      # The metadata for the Operation returned by CreateAuthorizedView.
+      class CreateAuthorizedViewMetadata
+        include Google::Apis::Core::Hashable
+      
+        # The time at which the operation failed or was completed successfully.
+        # Corresponds to the JSON property `finishTime`
+        # @return [String]
+        attr_accessor :finish_time
+      
+        # The request for CreateAuthorizedView
+        # Corresponds to the JSON property `originalRequest`
+        # @return [Google::Apis::BigtableadminV2::CreateAuthorizedViewRequest]
+        attr_accessor :original_request
+      
+        # The time at which the original request was received.
+        # Corresponds to the JSON property `requestTime`
+        # @return [String]
+        attr_accessor :request_time
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @finish_time = args[:finish_time] if args.key?(:finish_time)
+          @original_request = args[:original_request] if args.key?(:original_request)
+          @request_time = args[:request_time] if args.key?(:request_time)
+        end
+      end
+      
+      # The request for CreateAuthorizedView
+      class CreateAuthorizedViewRequest
+        include Google::Apis::Core::Hashable
+      
+        # Placeholder for admin API work while we work out the internals.
+        # Corresponds to the JSON property `authorizedView`
+        # @return [Google::Apis::BigtableadminV2::AuthorizedView]
+        attr_accessor :authorized_view
+      
+        # Required. The id of the AuthorizedView to create. This AuthorizedView must not
+        # already exist. The `authorized_view_id` appended to `parent` forms the full
+        # AuthorizedView name of the form `projects/`project`/instances/`instance`/
+        # tables/`table`/authorizedView/`authorized_view``.
+        # Corresponds to the JSON property `authorizedViewId`
+        # @return [String]
+        attr_accessor :authorized_view_id
+      
+        # Required. This is the name of the table the AuthorizedView belongs to. Values
+        # are of the form `projects/`project`/instances/`instance`/tables/`table``.
+        # Corresponds to the JSON property `parent`
+        # @return [String]
+        attr_accessor :parent
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @authorized_view = args[:authorized_view] if args.key?(:authorized_view)
+          @authorized_view_id = args[:authorized_view_id] if args.key?(:authorized_view_id)
+          @parent = args[:parent] if args.key?(:parent)
+        end
+      end
+      
       # Metadata type for the operation returned by CreateBackup.
       class CreateBackupMetadata
         include Google::Apis::Core::Hashable
@@ -1058,6 +1223,47 @@ module Google
         end
       end
       
+      # Data Boost is a serverless compute capability that lets you run high-
+      # throughput read jobs on your Bigtable data, without impacting the performance
+      # of the clusters that handle your application traffic. Currently, Data Boost
+      # exclusively supports read-only use-cases with single-cluster routing. Data
+      # Boost reads are only guaranteed to see the results of writes that were written
+      # at least 30 minutes ago. This means newly written values may not become
+      # visible for up to 30m, and also means that old values may remain visible for
+      # up to 30m after being deleted or overwritten. To mitigate the staleness of the
+      # data, users may either wait 30m, or use CheckConsistency.
+      class DataBoostIsolationReadOnly
+        include Google::Apis::Core::Hashable
+      
+        # The Compute Billing Owner for this Data Boost App Profile.
+        # Corresponds to the JSON property `computeBillingOwner`
+        # @return [String]
+        attr_accessor :compute_billing_owner
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @compute_billing_owner = args[:compute_billing_owner] if args.key?(:compute_billing_owner)
+        end
+      end
+      
+      # Checks that all writes before the consistency token was generated in the same
+      # cluster are readable by Databoost.
+      class DataBoostReadLocalWrites
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
       # Request message for google.bigtable.admin.v2.BigtableTableAdmin.DropRowRange
       class DropRowRangeRequest
         include Google::Apis::Core::Hashable
@@ -1339,6 +1545,271 @@ module Google
         end
       end
       
+      # Subsets of a column family that are included in this AuthorizedView.
+      class GoogleBigtableAdminV2AuthorizedViewFamilySubsets
+        include Google::Apis::Core::Hashable
+      
+        # Prefixes for qualifiers to be included in the AuthorizedView. Every qualifier
+        # starting with one of these prefixes is included in the AuthorizedView. To
+        # provide access to all qualifiers, include the empty string as a prefix ("").
+        # Corresponds to the JSON property `qualifierPrefixes`
+        # @return [Array<String>]
+        attr_accessor :qualifier_prefixes
+      
+        # Individual exact column qualifiers to be included in the AuthorizedView.
+        # Corresponds to the JSON property `qualifiers`
+        # @return [Array<String>]
+        attr_accessor :qualifiers
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @qualifier_prefixes = args[:qualifier_prefixes] if args.key?(:qualifier_prefixes)
+          @qualifiers = args[:qualifiers] if args.key?(:qualifiers)
+        end
+      end
+      
+      # Defines a simple AuthorizedView that is a subset of the underlying Table.
+      class GoogleBigtableAdminV2AuthorizedViewSubsetView
+        include Google::Apis::Core::Hashable
+      
+        # Map from column family name to the columns in this family to be included in
+        # the AuthorizedView.
+        # Corresponds to the JSON property `familySubsets`
+        # @return [Hash<String,Google::Apis::BigtableadminV2::GoogleBigtableAdminV2AuthorizedViewFamilySubsets>]
+        attr_accessor :family_subsets
+      
+        # Row prefixes to be included in the AuthorizedView. To provide access to all
+        # rows, include the empty string as a prefix ("").
+        # Corresponds to the JSON property `rowPrefixes`
+        # @return [Array<String>]
+        attr_accessor :row_prefixes
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @family_subsets = args[:family_subsets] if args.key?(:family_subsets)
+          @row_prefixes = args[:row_prefixes] if args.key?(:row_prefixes)
+        end
+      end
+      
+      # A value that combines incremental updates into a summarized value. Data is
+      # never directly written or read using type `Aggregate`. Writes will provide
+      # either the `input_type` or `state_type`, and reads will always return the `
+      # state_type` .
+      class GoogleBigtableAdminV2TypeAggregate
+        include Google::Apis::Core::Hashable
+      
+        # `Type` represents the type of data that is written to, read from, or stored in
+        # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
+        # familiarity and consistency across products and features. For compatibility
+        # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
+        # which describes how to convert to/from the underlying data. This might involve
+        # composing a series of steps into an "encoding chain," for example to convert
+        # from INT64 -> STRING -> raw bytes. In most cases, a "link" in the encoding
+        # chain will be based an on existing GoogleSQL conversion function like `CAST`.
+        # Each link in the encoding chain also defines the following properties: *
+        # Natural sort: Does the encoded value sort consistently with the original typed
+        # value? Note that Bigtable will always sort data based on the raw encoded value,
+        # *not* the decoded type. - Example: STRING values sort in the same order as
+        # their UTF-8 encodings. - Counterexample: Encoding INT64 to a fixed-width
+        # STRING does *not* preserve sort order when dealing with negative numbers.
+        # INT64(1) > INT64(-1), but STRING("-00001") > STRING("00001). - The overall
+        # encoding chain sorts naturally if *every* link does. * Self-delimiting: If we
+        # concatenate two encoded values, can we always tell where the first one ends
+        # and the second one begins? - Example: If we encode INT64s to fixed-width
+        # STRINGs, the first value will always contain exactly N digits, possibly
+        # preceded by a sign. - Counterexample: If we concatenate two UTF-8 encoded
+        # STRINGs, we have no way to tell where the first one ends. - The overall
+        # encoding chain is self-delimiting if *any* link is. * Compatibility: Which
+        # other systems have matching encoding schemes? For example, does this encoding
+        # have a GoogleSQL equivalent? HBase? Java?
+        # Corresponds to the JSON property `inputType`
+        # @return [Google::Apis::BigtableadminV2::Type]
+        attr_accessor :input_type
+      
+        # `Type` represents the type of data that is written to, read from, or stored in
+        # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
+        # familiarity and consistency across products and features. For compatibility
+        # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
+        # which describes how to convert to/from the underlying data. This might involve
+        # composing a series of steps into an "encoding chain," for example to convert
+        # from INT64 -> STRING -> raw bytes. In most cases, a "link" in the encoding
+        # chain will be based an on existing GoogleSQL conversion function like `CAST`.
+        # Each link in the encoding chain also defines the following properties: *
+        # Natural sort: Does the encoded value sort consistently with the original typed
+        # value? Note that Bigtable will always sort data based on the raw encoded value,
+        # *not* the decoded type. - Example: STRING values sort in the same order as
+        # their UTF-8 encodings. - Counterexample: Encoding INT64 to a fixed-width
+        # STRING does *not* preserve sort order when dealing with negative numbers.
+        # INT64(1) > INT64(-1), but STRING("-00001") > STRING("00001). - The overall
+        # encoding chain sorts naturally if *every* link does. * Self-delimiting: If we
+        # concatenate two encoded values, can we always tell where the first one ends
+        # and the second one begins? - Example: If we encode INT64s to fixed-width
+        # STRINGs, the first value will always contain exactly N digits, possibly
+        # preceded by a sign. - Counterexample: If we concatenate two UTF-8 encoded
+        # STRINGs, we have no way to tell where the first one ends. - The overall
+        # encoding chain is self-delimiting if *any* link is. * Compatibility: Which
+        # other systems have matching encoding schemes? For example, does this encoding
+        # have a GoogleSQL equivalent? HBase? Java?
+        # Corresponds to the JSON property `stateType`
+        # @return [Google::Apis::BigtableadminV2::Type]
+        attr_accessor :state_type
+      
+        # Computes the sum of the input values. Allowed input: `Int64` State: same as
+        # input
+        # Corresponds to the JSON property `sum`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregateSum]
+        attr_accessor :sum
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @input_type = args[:input_type] if args.key?(:input_type)
+          @state_type = args[:state_type] if args.key?(:state_type)
+          @sum = args[:sum] if args.key?(:sum)
+        end
+      end
+      
+      # Computes the sum of the input values. Allowed input: `Int64` State: same as
+      # input
+      class GoogleBigtableAdminV2TypeAggregateSum
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # Bytes Values of type `Bytes` are stored in `Value.bytes_value`.
+      class GoogleBigtableAdminV2TypeBytes
+        include Google::Apis::Core::Hashable
+      
+        # Rules used to convert to/from lower level types.
+        # Corresponds to the JSON property `encoding`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytesEncoding]
+        attr_accessor :encoding
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @encoding = args[:encoding] if args.key?(:encoding)
+        end
+      end
+      
+      # Rules used to convert to/from lower level types.
+      class GoogleBigtableAdminV2TypeBytesEncoding
+        include Google::Apis::Core::Hashable
+      
+        # Leaves the value "as-is" * Natural sort? Yes * Self-delimiting? No *
+        # Compatibility? N/A
+        # Corresponds to the JSON property `raw`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytesEncodingRaw]
+        attr_accessor :raw
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @raw = args[:raw] if args.key?(:raw)
+        end
+      end
+      
+      # Leaves the value "as-is" * Natural sort? Yes * Self-delimiting? No *
+      # Compatibility? N/A
+      class GoogleBigtableAdminV2TypeBytesEncodingRaw
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
+      # Int64 Values of type `Int64` are stored in `Value.int_value`.
+      class GoogleBigtableAdminV2TypeInt64
+        include Google::Apis::Core::Hashable
+      
+        # Rules used to convert to/from lower level types.
+        # Corresponds to the JSON property `encoding`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64Encoding]
+        attr_accessor :encoding
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @encoding = args[:encoding] if args.key?(:encoding)
+        end
+      end
+      
+      # Rules used to convert to/from lower level types.
+      class GoogleBigtableAdminV2TypeInt64Encoding
+        include Google::Apis::Core::Hashable
+      
+        # Encodes the value as an 8-byte big endian twos complement `Bytes` value. *
+        # Natural sort? No (positive values only) * Self-delimiting? Yes * Compatibility?
+        # - BigQuery Federation `BINARY` encoding - HBase `Bytes.toBytes` - Java `
+        # ByteBuffer.putLong()` with `ByteOrder.BIG_ENDIAN`
+        # Corresponds to the JSON property `bigEndianBytes`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes]
+        attr_accessor :big_endian_bytes
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @big_endian_bytes = args[:big_endian_bytes] if args.key?(:big_endian_bytes)
+        end
+      end
+      
+      # Encodes the value as an 8-byte big endian twos complement `Bytes` value. *
+      # Natural sort? No (positive values only) * Self-delimiting? Yes * Compatibility?
+      # - BigQuery Federation `BINARY` encoding - HBase `Bytes.toBytes` - Java `
+      # ByteBuffer.putLong()` with `ByteOrder.BIG_ENDIAN`
+      class GoogleBigtableAdminV2TypeInt64EncodingBigEndianBytes
+        include Google::Apis::Core::Hashable
+      
+        # Bytes Values of type `Bytes` are stored in `Value.bytes_value`.
+        # Corresponds to the JSON property `bytesType`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytes]
+        attr_accessor :bytes_type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @bytes_type = args[:bytes_type] if args.key?(:bytes_type)
+        end
+      end
+      
       # A tablet is a defined by a start and end key and is explained in https://cloud.
       # google.com/bigtable/docs/overview#architecture and https://cloud.google.com/
       # bigtable/docs/performance#optimization. A Hot tablet is a tablet that exhibits
@@ -1523,6 +1994,33 @@ module Google
         end
       end
       
+      # Response message for google.bigtable.admin.v2.BigtableTableAdmin.
+      # ListAuthorizedViews
+      class ListAuthorizedViewsResponse
+        include Google::Apis::Core::Hashable
+      
+        # The AuthorizedViews present in the requested table.
+        # Corresponds to the JSON property `authorizedViews`
+        # @return [Array<Google::Apis::BigtableadminV2::AuthorizedView>]
+        attr_accessor :authorized_views
+      
+        # Set if not all tables could be returned in a single response. Pass this value
+        # to `page_token` in another request to get the next page of results.
+        # Corresponds to the JSON property `nextPageToken`
+        # @return [String]
+        attr_accessor :next_page_token
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @authorized_views = args[:authorized_views] if args.key?(:authorized_views)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+        end
+      end
+      
       # The response for ListBackups.
       class ListBackupsResponse
         include Google::Apis::Core::Hashable
@@ -2400,6 +2898,20 @@ module Google
         end
       end
       
+      # Checks that all writes before the consistency token was generated are
+      # replicated in every cluster and readable.
+      class StandardReadRemoteWrites
+        include Google::Apis::Core::Hashable
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+        end
+      end
+      
       # The `Status` type defines a logical error model that is suitable for different
       # programming environments, including REST APIs and RPC APIs. It is used by [
       # gRPC](https://github.com/grpc). Each `Status` message contains three pieces of
@@ -2650,6 +3162,63 @@ module Google
         end
       end
       
+      # `Type` represents the type of data that is written to, read from, or stored in
+      # Bigtable. It is heavily based on the GoogleSQL standard to help maintain
+      # familiarity and consistency across products and features. For compatibility
+      # with Bigtable's existing untyped APIs, each `Type` includes an `Encoding`
+      # which describes how to convert to/from the underlying data. This might involve
+      # composing a series of steps into an "encoding chain," for example to convert
+      # from INT64 -> STRING -> raw bytes. In most cases, a "link" in the encoding
+      # chain will be based an on existing GoogleSQL conversion function like `CAST`.
+      # Each link in the encoding chain also defines the following properties: *
+      # Natural sort: Does the encoded value sort consistently with the original typed
+      # value? Note that Bigtable will always sort data based on the raw encoded value,
+      # *not* the decoded type. - Example: STRING values sort in the same order as
+      # their UTF-8 encodings. - Counterexample: Encoding INT64 to a fixed-width
+      # STRING does *not* preserve sort order when dealing with negative numbers.
+      # INT64(1) > INT64(-1), but STRING("-00001") > STRING("00001). - The overall
+      # encoding chain sorts naturally if *every* link does. * Self-delimiting: If we
+      # concatenate two encoded values, can we always tell where the first one ends
+      # and the second one begins? - Example: If we encode INT64s to fixed-width
+      # STRINGs, the first value will always contain exactly N digits, possibly
+      # preceded by a sign. - Counterexample: If we concatenate two UTF-8 encoded
+      # STRINGs, we have no way to tell where the first one ends. - The overall
+      # encoding chain is self-delimiting if *any* link is. * Compatibility: Which
+      # other systems have matching encoding schemes? For example, does this encoding
+      # have a GoogleSQL equivalent? HBase? Java?
+      class Type
+        include Google::Apis::Core::Hashable
+      
+        # A value that combines incremental updates into a summarized value. Data is
+        # never directly written or read using type `Aggregate`. Writes will provide
+        # either the `input_type` or `state_type`, and reads will always return the `
+        # state_type` .
+        # Corresponds to the JSON property `aggregateType`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeAggregate]
+        attr_accessor :aggregate_type
+      
+        # Bytes Values of type `Bytes` are stored in `Value.bytes_value`.
+        # Corresponds to the JSON property `bytesType`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeBytes]
+        attr_accessor :bytes_type
+      
+        # Int64 Values of type `Int64` are stored in `Value.int_value`.
+        # Corresponds to the JSON property `int64Type`
+        # @return [Google::Apis::BigtableadminV2::GoogleBigtableAdminV2TypeInt64]
+        attr_accessor :int64_type
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @aggregate_type = args[:aggregate_type] if args.key?(:aggregate_type)
+          @bytes_type = args[:bytes_type] if args.key?(:bytes_type)
+          @int64_type = args[:int64_type] if args.key?(:int64_type)
+        end
+      end
+      
       # Metadata type for the operation returned by google.bigtable.admin.v2.
       # BigtableTableAdmin.UndeleteTable.
       class UndeleteTableMetadata
@@ -2727,6 +3296,74 @@ module Google
         end
       end
       
+      # Metadata for the google.longrunning.Operation returned by UpdateAuthorizedView.
+      class UpdateAuthorizedViewMetadata
+        include Google::Apis::Core::Hashable
+      
+        # The time at which the operation failed or was completed successfully.
+        # Corresponds to the JSON property `finishTime`
+        # @return [String]
+        attr_accessor :finish_time
+      
+        # The request for UpdateAuthorizedView.
+        # Corresponds to the JSON property `originalRequest`
+        # @return [Google::Apis::BigtableadminV2::UpdateAuthorizedViewRequest]
+        attr_accessor :original_request
+      
+        # The time at which the original request was received.
+        # Corresponds to the JSON property `requestTime`
+        # @return [String]
+        attr_accessor :request_time
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @finish_time = args[:finish_time] if args.key?(:finish_time)
+          @original_request = args[:original_request] if args.key?(:original_request)
+          @request_time = args[:request_time] if args.key?(:request_time)
+        end
+      end
+      
+      # The request for UpdateAuthorizedView.
+      class UpdateAuthorizedViewRequest
+        include Google::Apis::Core::Hashable
+      
+        # Placeholder for admin API work while we work out the internals.
+        # Corresponds to the JSON property `authorizedView`
+        # @return [Google::Apis::BigtableadminV2::AuthorizedView]
+        attr_accessor :authorized_view
+      
+        # Optional. If true, ignore the safety checks when updating the AuthorizedView.
+        # Corresponds to the JSON property `ignoreWarnings`
+        # @return [Boolean]
+        attr_accessor :ignore_warnings
+        alias_method :ignore_warnings?, :ignore_warnings
+      
+        # Optional. The list of fields to update. A mask specifying which fields in the
+        # AuthorizedView resource should be updated. This mask is relative to the
+        # AuthorizedView resource, not to the request message. A field will be
+        # overwritten if it is in the mask. If empty, all fields set in the request will
+        # be overwritten. A special value `*` means to overwrite all fields (including
+        # fields not set in the request).
+        # Corresponds to the JSON property `updateMask`
+        # @return [String]
+        attr_accessor :update_mask
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @authorized_view = args[:authorized_view] if args.key?(:authorized_view)
+          @ignore_warnings = args[:ignore_warnings] if args.key?(:ignore_warnings)
+          @update_mask = args[:update_mask] if args.key?(:update_mask)
+        end
+      end
+      
       # The metadata for the Operation returned by UpdateCluster.
       class UpdateClusterMetadata
         include Google::Apis::Core::Hashable