google-apis-safebrowsing_v5 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca0806a5268a558f1c58507f6677511db33609ae3461c56e16cdcf100adfce7d
-  data.tar.gz: '0269a64cf797a72e6b59ca1fad3b4df2878e9f529d75350029f7ee3a6324b436'
+  metadata.gz: 9c3d3f4749d1fafab33be737ca87f0c7ce2c4fa0b6129e112a99ef9f54e54955
+  data.tar.gz: ea42bab59507470c6a8541bc9f1a2de8c6200d6b0559da359ea5a6165a2407af
 SHA512:
-  metadata.gz: f77ae59a5d83223e25bf9965352228bba5d24b38ae9f65c940080040267910da3e7adb046938b437b05507bb6b8ceb7df677e3601940956e2a00c0c9deba8349
-  data.tar.gz: 889506a9551b1c425feb37d9e29a35408dc415e79c3c7f919a3b30b88f267f650b1c817c81072cca83f941acdd3b651e2b8f92a1bd6c9165e8584d5eecb7e363
+  metadata.gz: 819ba445abd3aee5bc59800497950e0ddc050d4c70f492aed9d358a48f08c58d1f6f1ee06974e8c01f0052d4c16cf5b2dc70e432c89c9fcd200ed32196e20d92
+  data.tar.gz: 4c830394e974f62cb259839be2358ee32636671dc377e33525f993b2ed6098ce6d4d302cd7be279fd4c22a3d93714d52dec57056738d1fe724949a69988d084d

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Release history for google-apis-safebrowsing_v5
 
+### v0.8.0 (2025-05-25)
+
+* Regenerated from discovery document revision 20250518
+* Regenerated using generator version 0.18.0
+
 ### v0.7.0 (2025-05-04)
 
 * Regenerated using generator version 0.17.0

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

@@ -22,6 +22,25 @@ module Google
   module Apis
     module SafebrowsingV5
       
+      # The response containing multiple hash lists.
+      class GoogleSecuritySafebrowsingV5BatchGetHashListsResponse
+        include Google::Apis::Core::Hashable
+      
+        # The hash lists in the same order given in the request.
+        # Corresponds to the JSON property `hashLists`
+        # @return [Array<Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5HashList>]
+        attr_accessor :hash_lists
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @hash_lists = args[:hash_lists] if args.key?(:hash_lists)
+        end
+      end
+      
       # The full hash identified with one or more matches.
       class GoogleSecuritySafebrowsingV5FullHash
         include Google::Apis::Core::Hashable
@@ -86,6 +105,409 @@ module Google
         end
       end
       
+      # A list of hashes identified by its name.
+      class GoogleSecuritySafebrowsingV5HashList
+        include Google::Apis::Core::Hashable
+      
+        # Same as `RiceDeltaEncoded32Bit` except this encodes 64-bit numbers.
+        # Corresponds to the JSON property `additionsEightBytes`
+        # @return [Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded64Bit]
+        attr_accessor :additions_eight_bytes
+      
+        # The Rice-Golomb encoded data. Used for either hashes or removal indices. It is
+        # guaranteed that every hash or index here has the same length, and this length
+        # is exactly 32 bits. Generally speaking, if we sort all the entries
+        # lexicographically, we will find that the higher order bits tend not to change
+        # as frequently as lower order bits. This means that if we also take the
+        # adjacent difference between entries, the higher order bits have a high
+        # probability of being zero. This exploits this high probability of zero by
+        # essentially choosing a certain number of bits; all bits more significant than
+        # this are likely to be zero so we use unary encoding. See the `rice_parameter`
+        # field. Historical note: the Rice-delta encoding was first used in V4 of this
+        # API. In V5, two significant improvements were made: firstly, the Rice-delta
+        # encoding is now available with hash prefixes longer than 4 bytes; secondly,
+        # the encoded data are now treated as big-endian so as to avoid a costly sorting
+        # step.
+        # Corresponds to the JSON property `additionsFourBytes`
+        # @return [Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded32Bit]
+        attr_accessor :additions_four_bytes
+      
+        # Same as `RiceDeltaEncoded32Bit` except this encodes 128-bit numbers.
+        # Corresponds to the JSON property `additionsSixteenBytes`
+        # @return [Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded128Bit]
+        attr_accessor :additions_sixteen_bytes
+      
+        # Same as `RiceDeltaEncoded32Bit` except this encodes 256-bit numbers.
+        # Corresponds to the JSON property `additionsThirtyTwoBytes`
+        # @return [Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded256Bit]
+        attr_accessor :additions_thirty_two_bytes
+      
+        # The Rice-Golomb encoded data. Used for either hashes or removal indices. It is
+        # guaranteed that every hash or index here has the same length, and this length
+        # is exactly 32 bits. Generally speaking, if we sort all the entries
+        # lexicographically, we will find that the higher order bits tend not to change
+        # as frequently as lower order bits. This means that if we also take the
+        # adjacent difference between entries, the higher order bits have a high
+        # probability of being zero. This exploits this high probability of zero by
+        # essentially choosing a certain number of bits; all bits more significant than
+        # this are likely to be zero so we use unary encoding. See the `rice_parameter`
+        # field. Historical note: the Rice-delta encoding was first used in V4 of this
+        # API. In V5, two significant improvements were made: firstly, the Rice-delta
+        # encoding is now available with hash prefixes longer than 4 bytes; secondly,
+        # the encoded data are now treated as big-endian so as to avoid a costly sorting
+        # step.
+        # Corresponds to the JSON property `compressedRemovals`
+        # @return [Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded32Bit]
+        attr_accessor :compressed_removals
+      
+        # Metadata about a particular hash list.
+        # Corresponds to the JSON property `metadata`
+        # @return [Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5HashListMetadata]
+        attr_accessor :metadata
+      
+        # Clients should wait at least this long to get the hash list again. If omitted
+        # or zero, clients SHOULD fetch immediately because it indicates that the server
+        # has an additional update to be sent to the client, but could not due to the
+        # client-specified constraints.
+        # Corresponds to the JSON property `minimumWaitDuration`
+        # @return [String]
+        attr_accessor :minimum_wait_duration
+      
+        # The name of the hash list. Note that the Global Cache is also just a hash list
+        # and can be referred to here.
+        # Corresponds to the JSON property `name`
+        # @return [String]
+        attr_accessor :name
+      
+        # When true, this is a partial diff containing additions and removals based on
+        # what the client already has. When false, this is the complete hash list. When
+        # false, the client MUST delete any locally stored version for this hash list.
+        # This means that either the version possessed by the client is seriously out-of-
+        # date or the client data is believed to be corrupt. The `compressed_removals`
+        # field will be empty. When true, the client MUST apply an incremental update by
+        # applying removals and then additions.
+        # Corresponds to the JSON property `partialUpdate`
+        # @return [Boolean]
+        attr_accessor :partial_update
+        alias_method :partial_update?, :partial_update
+      
+        # The sorted list of all hashes, hashed again with SHA256. This is the checksum
+        # for the sorted list of all hashes present in the database after applying the
+        # provided update. In the case that no updates were provided, the server will
+        # omit this field to indicate that the client should use the existing checksum.
+        # Corresponds to the JSON property `sha256Checksum`
+        # NOTE: Values are automatically base64 encoded/decoded in the client library.
+        # @return [String]
+        attr_accessor :sha256_checksum
+      
+        # The version of the hash list. The client MUST NOT manipulate those bytes.
+        # Corresponds to the JSON property `version`
+        # NOTE: Values are automatically base64 encoded/decoded in the client library.
+        # @return [String]
+        attr_accessor :version
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @additions_eight_bytes = args[:additions_eight_bytes] if args.key?(:additions_eight_bytes)
+          @additions_four_bytes = args[:additions_four_bytes] if args.key?(:additions_four_bytes)
+          @additions_sixteen_bytes = args[:additions_sixteen_bytes] if args.key?(:additions_sixteen_bytes)
+          @additions_thirty_two_bytes = args[:additions_thirty_two_bytes] if args.key?(:additions_thirty_two_bytes)
+          @compressed_removals = args[:compressed_removals] if args.key?(:compressed_removals)
+          @metadata = args[:metadata] if args.key?(:metadata)
+          @minimum_wait_duration = args[:minimum_wait_duration] if args.key?(:minimum_wait_duration)
+          @name = args[:name] if args.key?(:name)
+          @partial_update = args[:partial_update] if args.key?(:partial_update)
+          @sha256_checksum = args[:sha256_checksum] if args.key?(:sha256_checksum)
+          @version = args[:version] if args.key?(:version)
+        end
+      end
+      
+      # Metadata about a particular hash list.
+      class GoogleSecuritySafebrowsingV5HashListMetadata
+        include Google::Apis::Core::Hashable
+      
+        # A human-readable description about this list. Written in English.
+        # Corresponds to the JSON property `description`
+        # @return [String]
+        attr_accessor :description
+      
+        # The supported hash length for this hash list. Each hash list will support
+        # exactly one length. If a different hash length is introduced for the same set
+        # of threat types or safe types, it will be introduced as a separate list with a
+        # distinct name and respective hash length set.
+        # Corresponds to the JSON property `hashLength`
+        # @return [String]
+        attr_accessor :hash_length
+      
+        # Unordered list. If not empty, this specifies that the hash list represents a
+        # list of likely safe hashes, and this enumerates the ways they are considered
+        # likely safe. This field is mutually exclusive with the threat_types field.
+        # Corresponds to the JSON property `likelySafeTypes`
+        # @return [Array<String>]
+        attr_accessor :likely_safe_types
+      
+        # Unordered list. If not empty, this specifies that the hash list is a kind of
+        # threat list, and this enumerates the kind of threats associated with hashes or
+        # hash prefixes in this hash list. May be empty if the entry does not represent
+        # a threat, i.e. in the case that it represents a likely safe type.
+        # Corresponds to the JSON property `threatTypes`
+        # @return [Array<String>]
+        attr_accessor :threat_types
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @description = args[:description] if args.key?(:description)
+          @hash_length = args[:hash_length] if args.key?(:hash_length)
+          @likely_safe_types = args[:likely_safe_types] if args.key?(:likely_safe_types)
+          @threat_types = args[:threat_types] if args.key?(:threat_types)
+        end
+      end
+      
+      # The response containing metadata about hash lists.
+      class GoogleSecuritySafebrowsingV5ListHashListsResponse
+        include Google::Apis::Core::Hashable
+      
+        # The hash lists in an arbitrary order. Only metadata about the hash lists will
+        # be included, not the contents.
+        # Corresponds to the JSON property `hashLists`
+        # @return [Array<Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5HashList>]
+        attr_accessor :hash_lists
+      
+        # A token, which can be sent as `page_token` to retrieve the next page. If this
+        # field is omitted, there are no subsequent pages.
+        # 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)
+          @hash_lists = args[:hash_lists] if args.key?(:hash_lists)
+          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
+        end
+      end
+      
+      # Same as `RiceDeltaEncoded32Bit` except this encodes 128-bit numbers.
+      class GoogleSecuritySafebrowsingV5RiceDeltaEncoded128Bit
+        include Google::Apis::Core::Hashable
+      
+        # The encoded deltas that are encoded using the Golomb-Rice coder.
+        # Corresponds to the JSON property `encodedData`
+        # NOTE: Values are automatically base64 encoded/decoded in the client library.
+        # @return [String]
+        attr_accessor :encoded_data
+      
+        # The number of entries that are delta encoded in the encoded data. If only a
+        # single integer was encoded, this will be zero and the single value will be
+        # stored in `first_value`.
+        # Corresponds to the JSON property `entriesCount`
+        # @return [Fixnum]
+        attr_accessor :entries_count
+      
+        # The upper 64 bits of the first entry in the encoded data (hashes). If the
+        # field is empty, the upper 64 bits are all zero.
+        # Corresponds to the JSON property `firstValueHi`
+        # @return [Fixnum]
+        attr_accessor :first_value_hi
+      
+        # The lower 64 bits of the first entry in the encoded data (hashes). If the
+        # field is empty, the lower 64 bits are all zero.
+        # Corresponds to the JSON property `firstValueLo`
+        # @return [Fixnum]
+        attr_accessor :first_value_lo
+      
+        # The Golomb-Rice parameter. This parameter is guaranteed to be between 99 and
+        # 126, inclusive.
+        # Corresponds to the JSON property `riceParameter`
+        # @return [Fixnum]
+        attr_accessor :rice_parameter
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @encoded_data = args[:encoded_data] if args.key?(:encoded_data)
+          @entries_count = args[:entries_count] if args.key?(:entries_count)
+          @first_value_hi = args[:first_value_hi] if args.key?(:first_value_hi)
+          @first_value_lo = args[:first_value_lo] if args.key?(:first_value_lo)
+          @rice_parameter = args[:rice_parameter] if args.key?(:rice_parameter)
+        end
+      end
+      
+      # Same as `RiceDeltaEncoded32Bit` except this encodes 256-bit numbers.
+      class GoogleSecuritySafebrowsingV5RiceDeltaEncoded256Bit
+        include Google::Apis::Core::Hashable
+      
+        # The encoded deltas that are encoded using the Golomb-Rice coder.
+        # Corresponds to the JSON property `encodedData`
+        # NOTE: Values are automatically base64 encoded/decoded in the client library.
+        # @return [String]
+        attr_accessor :encoded_data
+      
+        # The number of entries that are delta encoded in the encoded data. If only a
+        # single integer was encoded, this will be zero and the single value will be
+        # stored in `first_value`.
+        # Corresponds to the JSON property `entriesCount`
+        # @return [Fixnum]
+        attr_accessor :entries_count
+      
+        # The first 64 bits of the first entry in the encoded data (hashes). If the
+        # field is empty, the first 64 bits are all zero.
+        # Corresponds to the JSON property `firstValueFirstPart`
+        # @return [Fixnum]
+        attr_accessor :first_value_first_part
+      
+        # The last 64 bits of the first entry in the encoded data (hashes). If the field
+        # is empty, the last 64 bits are all zero.
+        # Corresponds to the JSON property `firstValueFourthPart`
+        # @return [Fixnum]
+        attr_accessor :first_value_fourth_part
+      
+        # The 65 through 128th bits of the first entry in the encoded data (hashes). If
+        # the field is empty, the 65 through 128th bits are all zero.
+        # Corresponds to the JSON property `firstValueSecondPart`
+        # @return [Fixnum]
+        attr_accessor :first_value_second_part
+      
+        # The 129 through 192th bits of the first entry in the encoded data (hashes). If
+        # the field is empty, the 129 through 192th bits are all zero.
+        # Corresponds to the JSON property `firstValueThirdPart`
+        # @return [Fixnum]
+        attr_accessor :first_value_third_part
+      
+        # The Golomb-Rice parameter. This parameter is guaranteed to be between 227 and
+        # 254, inclusive.
+        # Corresponds to the JSON property `riceParameter`
+        # @return [Fixnum]
+        attr_accessor :rice_parameter
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @encoded_data = args[:encoded_data] if args.key?(:encoded_data)
+          @entries_count = args[:entries_count] if args.key?(:entries_count)
+          @first_value_first_part = args[:first_value_first_part] if args.key?(:first_value_first_part)
+          @first_value_fourth_part = args[:first_value_fourth_part] if args.key?(:first_value_fourth_part)
+          @first_value_second_part = args[:first_value_second_part] if args.key?(:first_value_second_part)
+          @first_value_third_part = args[:first_value_third_part] if args.key?(:first_value_third_part)
+          @rice_parameter = args[:rice_parameter] if args.key?(:rice_parameter)
+        end
+      end
+      
+      # The Rice-Golomb encoded data. Used for either hashes or removal indices. It is
+      # guaranteed that every hash or index here has the same length, and this length
+      # is exactly 32 bits. Generally speaking, if we sort all the entries
+      # lexicographically, we will find that the higher order bits tend not to change
+      # as frequently as lower order bits. This means that if we also take the
+      # adjacent difference between entries, the higher order bits have a high
+      # probability of being zero. This exploits this high probability of zero by
+      # essentially choosing a certain number of bits; all bits more significant than
+      # this are likely to be zero so we use unary encoding. See the `rice_parameter`
+      # field. Historical note: the Rice-delta encoding was first used in V4 of this
+      # API. In V5, two significant improvements were made: firstly, the Rice-delta
+      # encoding is now available with hash prefixes longer than 4 bytes; secondly,
+      # the encoded data are now treated as big-endian so as to avoid a costly sorting
+      # step.
+      class GoogleSecuritySafebrowsingV5RiceDeltaEncoded32Bit
+        include Google::Apis::Core::Hashable
+      
+        # The encoded deltas that are encoded using the Golomb-Rice coder.
+        # Corresponds to the JSON property `encodedData`
+        # NOTE: Values are automatically base64 encoded/decoded in the client library.
+        # @return [String]
+        attr_accessor :encoded_data
+      
+        # The number of entries that are delta encoded in the encoded data. If only a
+        # single integer was encoded, this will be zero and the single value will be
+        # stored in `first_value`.
+        # Corresponds to the JSON property `entriesCount`
+        # @return [Fixnum]
+        attr_accessor :entries_count
+      
+        # The first entry in the encoded data (hashes or indices), or, if only a single
+        # hash prefix or index was encoded, that entry's value. If the field is empty,
+        # the entry is zero.
+        # Corresponds to the JSON property `firstValue`
+        # @return [Fixnum]
+        attr_accessor :first_value
+      
+        # The Golomb-Rice parameter. This parameter is guaranteed to be between 3 and 30,
+        # inclusive.
+        # Corresponds to the JSON property `riceParameter`
+        # @return [Fixnum]
+        attr_accessor :rice_parameter
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @encoded_data = args[:encoded_data] if args.key?(:encoded_data)
+          @entries_count = args[:entries_count] if args.key?(:entries_count)
+          @first_value = args[:first_value] if args.key?(:first_value)
+          @rice_parameter = args[:rice_parameter] if args.key?(:rice_parameter)
+        end
+      end
+      
+      # Same as `RiceDeltaEncoded32Bit` except this encodes 64-bit numbers.
+      class GoogleSecuritySafebrowsingV5RiceDeltaEncoded64Bit
+        include Google::Apis::Core::Hashable
+      
+        # The encoded deltas that are encoded using the Golomb-Rice coder.
+        # Corresponds to the JSON property `encodedData`
+        # NOTE: Values are automatically base64 encoded/decoded in the client library.
+        # @return [String]
+        attr_accessor :encoded_data
+      
+        # The number of entries that are delta encoded in the encoded data. If only a
+        # single integer was encoded, this will be zero and the single value will be
+        # stored in `first_value`.
+        # Corresponds to the JSON property `entriesCount`
+        # @return [Fixnum]
+        attr_accessor :entries_count
+      
+        # The first entry in the encoded data (hashes), or, if only a single hash prefix
+        # was encoded, that entry's value. If the field is empty, the entry is zero.
+        # Corresponds to the JSON property `firstValue`
+        # @return [Fixnum]
+        attr_accessor :first_value
+      
+        # The Golomb-Rice parameter. This parameter is guaranteed to be between 35 and
+        # 62, inclusive.
+        # Corresponds to the JSON property `riceParameter`
+        # @return [Fixnum]
+        attr_accessor :rice_parameter
+      
+        def initialize(**args)
+           update!(**args)
+        end
+      
+        # Update properties of this object
+        def update!(**args)
+          @encoded_data = args[:encoded_data] if args.key?(:encoded_data)
+          @entries_count = args[:entries_count] if args.key?(:entries_count)
+          @first_value = args[:first_value] if args.key?(:first_value)
+          @rice_parameter = args[:rice_parameter] if args.key?(:rice_parameter)
+        end
+      end
+      
       # The response returned after searching threat hashes. If nothing is found, the
       # server will return an OK status (HTTP status code 200) with the `full_hashes`
       # field empty, rather than returning a NOT_FOUND status (HTTP status code 404). *

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

@@ -16,13 +16,13 @@ module Google
   module Apis
     module SafebrowsingV5
       # Version of the google-apis-safebrowsing_v5 gem
-      GEM_VERSION = "0.7.0"
+      GEM_VERSION = "0.8.0"
 
       # Version of the code generator used to generate this client
-      GENERATOR_VERSION = "0.17.0"
+      GENERATOR_VERSION = "0.18.0"
 
       # Revision of the discovery document this client was generated from
-      REVISION = "20240505"
+      REVISION = "20250518"
     end
   end
 end

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

@@ -22,6 +22,12 @@ module Google
   module Apis
     module SafebrowsingV5
       
+      class GoogleSecuritySafebrowsingV5BatchGetHashListsResponse
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
       class GoogleSecuritySafebrowsingV5FullHash
         class Representation < Google::Apis::Core::JsonRepresentation; end
       
@@ -34,12 +40,62 @@ module Google
         include Google::Apis::Core::JsonObjectSupport
       end
       
+      class GoogleSecuritySafebrowsingV5HashList
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleSecuritySafebrowsingV5HashListMetadata
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleSecuritySafebrowsingV5ListHashListsResponse
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleSecuritySafebrowsingV5RiceDeltaEncoded128Bit
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleSecuritySafebrowsingV5RiceDeltaEncoded256Bit
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleSecuritySafebrowsingV5RiceDeltaEncoded32Bit
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
+      class GoogleSecuritySafebrowsingV5RiceDeltaEncoded64Bit
+        class Representation < Google::Apis::Core::JsonRepresentation; end
+      
+        include Google::Apis::Core::JsonObjectSupport
+      end
+      
       class GoogleSecuritySafebrowsingV5SearchHashesResponse
         class Representation < Google::Apis::Core::JsonRepresentation; end
       
         include Google::Apis::Core::JsonObjectSupport
       end
       
+      class GoogleSecuritySafebrowsingV5BatchGetHashListsResponse
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          collection :hash_lists, as: 'hashLists', class: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5HashList, decorator: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5HashList::Representation
+      
+        end
+      end
+      
       class GoogleSecuritySafebrowsingV5FullHash
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation
@@ -57,6 +113,92 @@ module Google
         end
       end
       
+      class GoogleSecuritySafebrowsingV5HashList
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :additions_eight_bytes, as: 'additionsEightBytes', class: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded64Bit, decorator: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded64Bit::Representation
+      
+          property :additions_four_bytes, as: 'additionsFourBytes', class: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded32Bit, decorator: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded32Bit::Representation
+      
+          property :additions_sixteen_bytes, as: 'additionsSixteenBytes', class: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded128Bit, decorator: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded128Bit::Representation
+      
+          property :additions_thirty_two_bytes, as: 'additionsThirtyTwoBytes', class: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded256Bit, decorator: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded256Bit::Representation
+      
+          property :compressed_removals, as: 'compressedRemovals', class: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded32Bit, decorator: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5RiceDeltaEncoded32Bit::Representation
+      
+          property :metadata, as: 'metadata', class: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5HashListMetadata, decorator: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5HashListMetadata::Representation
+      
+          property :minimum_wait_duration, as: 'minimumWaitDuration'
+          property :name, as: 'name'
+          property :partial_update, as: 'partialUpdate'
+          property :sha256_checksum, :base64 => true, as: 'sha256Checksum'
+          property :version, :base64 => true, as: 'version'
+        end
+      end
+      
+      class GoogleSecuritySafebrowsingV5HashListMetadata
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :description, as: 'description'
+          property :hash_length, as: 'hashLength'
+          collection :likely_safe_types, as: 'likelySafeTypes'
+          collection :threat_types, as: 'threatTypes'
+        end
+      end
+      
+      class GoogleSecuritySafebrowsingV5ListHashListsResponse
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          collection :hash_lists, as: 'hashLists', class: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5HashList, decorator: Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5HashList::Representation
+      
+          property :next_page_token, as: 'nextPageToken'
+        end
+      end
+      
+      class GoogleSecuritySafebrowsingV5RiceDeltaEncoded128Bit
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :encoded_data, :base64 => true, as: 'encodedData'
+          property :entries_count, as: 'entriesCount'
+          property :first_value_hi, :numeric_string => true, as: 'firstValueHi'
+          property :first_value_lo, :numeric_string => true, as: 'firstValueLo'
+          property :rice_parameter, as: 'riceParameter'
+        end
+      end
+      
+      class GoogleSecuritySafebrowsingV5RiceDeltaEncoded256Bit
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :encoded_data, :base64 => true, as: 'encodedData'
+          property :entries_count, as: 'entriesCount'
+          property :first_value_first_part, :numeric_string => true, as: 'firstValueFirstPart'
+          property :first_value_fourth_part, :numeric_string => true, as: 'firstValueFourthPart'
+          property :first_value_second_part, :numeric_string => true, as: 'firstValueSecondPart'
+          property :first_value_third_part, :numeric_string => true, as: 'firstValueThirdPart'
+          property :rice_parameter, as: 'riceParameter'
+        end
+      end
+      
+      class GoogleSecuritySafebrowsingV5RiceDeltaEncoded32Bit
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :encoded_data, :base64 => true, as: 'encodedData'
+          property :entries_count, as: 'entriesCount'
+          property :first_value, as: 'firstValue'
+          property :rice_parameter, as: 'riceParameter'
+        end
+      end
+      
+      class GoogleSecuritySafebrowsingV5RiceDeltaEncoded64Bit
+        # @private
+        class Representation < Google::Apis::Core::JsonRepresentation
+          property :encoded_data, :base64 => true, as: 'encodedData'
+          property :entries_count, as: 'entriesCount'
+          property :first_value, :numeric_string => true, as: 'firstValue'
+          property :rice_parameter, as: 'riceParameter'
+        end
+      end
+      
       class GoogleSecuritySafebrowsingV5SearchHashesResponse
         # @private
         class Representation < Google::Apis::Core::JsonRepresentation

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

@@ -55,6 +55,157 @@ module Google
           @batch_path = 'batch'
         end
         
+        # Get the latest contents of a hash list. A hash list may either by a threat
+        # list or a non-threat list such as the Global Cache. This is a standard Get
+        # method as defined by https://google.aip.dev/131 and the HTTP method is also
+        # GET.
+        # @param [String] name
+        #   Required. The name of this particular hash list. It may be a threat list, or
+        #   it may be the Global Cache.
+        # @param [Fixnum] size_constraints_max_database_entries
+        #   Sets the maximum number of entries that the client is willing to have in the
+        #   local database for the list. (The server MAY cause the client to store less
+        #   than this number of entries.) If omitted or zero, no database size limit is
+        #   set.
+        # @param [Fixnum] size_constraints_max_update_entries
+        #   The maximum size in number of entries. The update will not contain more
+        #   entries than this value, but it is possible that the update will contain fewer
+        #   entries than this value. This MUST be at least 1024. If omitted or zero, no
+        #   update size limit is set.
+        # @param [String] version
+        #   The version of the hash list that the client already has. If this is the first
+        #   time the client is fetching the hash list, this field MUST be left empty.
+        #   Otherwise, the client SHOULD supply the version previously received from the
+        #   server. The client MUST NOT manipulate those bytes. **What's new in V5**: in
+        #   V4 of the API, this was called `states`; it is now renamed to `version` for
+        #   clarity.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5HashList] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5HashList]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def get_hash_list(name, size_constraints_max_database_entries: nil, size_constraints_max_update_entries: nil, version: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v5/hashList/{name}', options)
+          command.response_representation = Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5HashList::Representation
+          command.response_class = Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5HashList
+          command.params['name'] = name unless name.nil?
+          command.query['sizeConstraints.maxDatabaseEntries'] = size_constraints_max_database_entries unless size_constraints_max_database_entries.nil?
+          command.query['sizeConstraints.maxUpdateEntries'] = size_constraints_max_update_entries unless size_constraints_max_update_entries.nil?
+          command.query['version'] = version unless version.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # Get multiple hash lists at once. It is very common for a client to need to get
+        # multiple hash lists. Using this method is preferred over using the regular Get
+        # method multiple times. This is a standard batch Get method as defined by https:
+        # //google.aip.dev/231 and the HTTP method is also GET.
+        # @param [Array<String>, String] names
+        #   Required. The names of the particular hash lists. The list MAY be a threat
+        #   list, or it may be the Global Cache. The names MUST NOT contain duplicates; if
+        #   they did, the client will get an error.
+        # @param [Fixnum] size_constraints_max_database_entries
+        #   Sets the maximum number of entries that the client is willing to have in the
+        #   local database for the list. (The server MAY cause the client to store less
+        #   than this number of entries.) If omitted or zero, no database size limit is
+        #   set.
+        # @param [Fixnum] size_constraints_max_update_entries
+        #   The maximum size in number of entries. The update will not contain more
+        #   entries than this value, but it is possible that the update will contain fewer
+        #   entries than this value. This MUST be at least 1024. If omitted or zero, no
+        #   update size limit is set.
+        # @param [Array<String>, String] version
+        #   The versions of the hash list that the client already has. If this is the
+        #   first time the client is fetching the hash lists, the field should be left
+        #   empty. Otherwise, the client should supply the versions previously received
+        #   from the server. The client MUST NOT manipulate those bytes. The client need
+        #   not send the versions in the same order as the corresponding list names. The
+        #   client may send fewer or more versions in a request than there are names.
+        #   However the client MUST NOT send multiple versions that correspond to the same
+        #   name; if it did, the client will get an error. Historical note: in V4 of the
+        #   API, this was called `states`; it is now renamed to `version` for clarity.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5BatchGetHashListsResponse] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5BatchGetHashListsResponse]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def batch_hash_list_get(names: nil, size_constraints_max_database_entries: nil, size_constraints_max_update_entries: nil, version: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v5/hashLists:batchGet', options)
+          command.response_representation = Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5BatchGetHashListsResponse::Representation
+          command.response_class = Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5BatchGetHashListsResponse
+          command.query['names'] = names unless names.nil?
+          command.query['sizeConstraints.maxDatabaseEntries'] = size_constraints_max_database_entries unless size_constraints_max_database_entries.nil?
+          command.query['sizeConstraints.maxUpdateEntries'] = size_constraints_max_update_entries unless size_constraints_max_update_entries.nil?
+          command.query['version'] = version unless version.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
+        # List hash lists. In the V5 API, Google will never remove a hash list that has
+        # ever been returned by this method. This enables clients to skip using this
+        # method and simply hard-code all hash lists they need. This is a standard List
+        # method as defined by https://google.aip.dev/132 and the HTTP method is GET.
+        # @param [Fixnum] page_size
+        #   The maximum number of hash lists to return. The service may return fewer than
+        #   this value. If unspecified, the server will choose a page size, which may be
+        #   larger than the number of hash lists so that pagination is not necessary.
+        # @param [String] page_token
+        #   A page token, received from a previous `ListHashLists` call. Provide this to
+        #   retrieve the subsequent page.
+        # @param [String] fields
+        #   Selector specifying which fields to include in a partial response.
+        # @param [String] quota_user
+        #   Available to use for quota purposes for server-side applications. Can be any
+        #   arbitrary string assigned to a user, but should not exceed 40 characters.
+        # @param [Google::Apis::RequestOptions] options
+        #   Request-specific options
+        #
+        # @yield [result, err] Result & error if block supplied
+        # @yieldparam result [Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5ListHashListsResponse] parsed result object
+        # @yieldparam err [StandardError] error object if request failed
+        #
+        # @return [Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5ListHashListsResponse]
+        #
+        # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried
+        # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification
+        # @raise [Google::Apis::AuthorizationError] Authorization is required
+        def list_hash_lists(page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block)
+          command = make_simple_command(:get, 'v5/hashLists', options)
+          command.response_representation = Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5ListHashListsResponse::Representation
+          command.response_class = Google::Apis::SafebrowsingV5::GoogleSecuritySafebrowsingV5ListHashListsResponse
+          command.query['pageSize'] = page_size unless page_size.nil?
+          command.query['pageToken'] = page_token unless page_token.nil?
+          command.query['fields'] = fields unless fields.nil?
+          command.query['quotaUser'] = quota_user unless quota_user.nil?
+          execute_or_queue_command(command, &block)
+        end
+        
         # Search for full hashes matching the specified prefixes. This is a custom
         # method as defined by https://google.aip.dev/136 (the custom method refers to
         # this method having a custom name within Google's general API development

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: google-apis-safebrowsing_v5
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Google LLC
@@ -57,7 +57,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-safebrowsing_v5/CHANGELOG.md
-  documentation_uri: https://googleapis.dev/ruby/google-apis-safebrowsing_v5/v0.7.0
+  documentation_uri: https://googleapis.dev/ruby/google-apis-safebrowsing_v5/v0.8.0
   source_code_uri: https://github.com/googleapis/google-api-ruby-client/tree/main/generated/google-apis-safebrowsing_v5
 rdoc_options: []
 require_paths:
@@ -73,7 +73,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Simple REST client for Safe Browsing API V5
 test_files: []