google-apis-deploymentmanager_v2beta 0.14.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d863def7beffd39ed42fcaa67bb63cfa552757bcc4518a7edf33a4b405bed666
-  data.tar.gz: 05271c842cfb04127ee8e56ec42d55a2dd0d36f77391e029953b4ca0b4cdbf9d
+  metadata.gz: 39319aeb9867ed354a73b232bf3c0d858daabf491ec5b601a1c8ef132ec2efe8
+  data.tar.gz: a6e99eb71a705921b059ce542e8dd8609f519e10917b0d219e51532eb8155c1b
 SHA512:
-  metadata.gz: 55b1f2380c1ae99b20ab8b9644f97fa653dca77358e01eb45585510a2da8a0965dd334c182ec5ad5483ae771f8e39f18a6dd7f42accb18d1be29d657c2db9706
-  data.tar.gz: ed9ce344a866ee407067689229ed7cb3c4377ba76d835cc21c69627afe87d9106c51156dab92ac17399287f418d75f226471a35ab155f4d7bcb1134029adcdb1
+  metadata.gz: 2f574e7259a37249b92777cd3bffd0e67598b4d23219bc26e824a06a38e99f1ef24e4c4c3f97602f6b317339edea4c993ae5ebc0e7ebbecde870279974eea756
+  data.tar.gz: 1a123d2a6e66ab03af193582f8dd22707cc28c66e57cc6bdf4b312170db559deb5b0a0ab929819f74ebab9cadafe8166360a3c74f0815f11a43700b2bb51b944

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Release history for google-apis-deploymentmanager_v2beta
 
+### v0.17.0 (2022-06-07)
+
+* Regenerated using generator version 0.5.0
+
+### v0.16.0 (2022-05-27)
+
+* Regenerated from discovery document revision 20220520
+
+### v0.15.0 (2022-05-05)
+
+* Regenerated from discovery document revision 20220429
+
 ### v0.14.0 (2022-04-14)
 
 * Regenerated from discovery document revision 20220407

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

@@ -62,8 +62,8 @@ module Google
       # "audit_log_configs": [ ` "log_type": "DATA_READ" `, ` "log_type": "DATA_WRITE"
       # , "exempted_members": [ "user:aliya@example.com" ] ` ] ` ] ` For sampleservice,
       # this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also
-      # exempts jose@example.com from DATA_READ logging, and aliya@example.com from
-      # DATA_WRITE logging.
+      # exempts `jose@example.com` from DATA_READ logging, and `aliya@example.com`
+      # from DATA_WRITE logging.
       class AuditConfig
         include Google::Apis::Core::Hashable
       

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

@@ -16,13 +16,13 @@ module Google
   module Apis
     module DeploymentmanagerV2beta
       # Version of the google-apis-deploymentmanager_v2beta gem
-      GEM_VERSION = "0.14.0"
+      GEM_VERSION = "0.17.0"
 
       # Version of the code generator used to generate this client
-      GENERATOR_VERSION = "0.4.1"
+      GENERATOR_VERSION = "0.5.0"
 
       # Revision of the discovery document this client was generated from
-      REVISION = "20220407"
+      REVISION = "20220520"
     end
   end
 end

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

@@ -154,25 +154,36 @@ module Google
         # @param [String] project
         #   The project ID for this request.
         # @param [String] filter
-        #   A filter expression that filters resources listed in the response. The
-        #   expression must specify the field name, an operator, and the value that you
-        #   want to use for filtering. The value must be a string, a number, or a boolean.
-        #   The operator must be either `=`, `!=`, `>`, `<`, `<=`, `>=` or `:`. For
-        #   example, if you are filtering Compute Engine instances, you can exclude
-        #   instances named `example-instance` by specifying `name != example-instance`.
-        #   The `:` operator can be used with string fields to match substrings. For non-
-        #   string fields it is equivalent to the `=` operator. The `:*` comparison can be
-        #   used to test whether a key has been defined. For example, to find all objects
-        #   with `owner` label use: ``` labels.owner:* ``` You can also filter nested
-        #   fields. For example, you could specify `scheduling.automaticRestart = false`
-        #   to include instances only if they are not scheduled for automatic restarts.
-        #   You can use filtering on nested fields to filter based on resource labels. To
-        #   filter on multiple expressions, provide each separate expression within
-        #   parentheses. For example: ``` (scheduling.automaticRestart = true) (
-        #   cpuPlatform = "Intel Skylake") ``` By default, each expression is an `AND`
-        #   expression. However, you can include `AND` and `OR` expressions explicitly.
-        #   For example: ``` (cpuPlatform = "Intel Skylake") OR (cpuPlatform = "Intel
-        #   Broadwell") AND (scheduling.automaticRestart = true) ```
+        #   A filter expression that filters resources listed in the response. Most
+        #   Compute resources support two types of filter expressions: expressions that
+        #   support regular expressions and expressions that follow API improvement
+        #   proposal AIP-160. If you want to use AIP-160, your expression must specify the
+        #   field name, an operator, and the value that you want to use for filtering. The
+        #   value must be a string, a number, or a boolean. The operator must be either `=`
+        #   , `!=`, `>`, `<`, `<=`, `>=` or `:`. For example, if you are filtering Compute
+        #   Engine instances, you can exclude instances named `example-instance` by
+        #   specifying `name != example-instance`. The `:` operator can be used with
+        #   string fields to match substrings. For non-string fields it is equivalent to
+        #   the `=` operator. The `:*` comparison can be used to test whether a key has
+        #   been defined. For example, to find all objects with `owner` label use: ```
+        #   labels.owner:* ``` You can also filter nested fields. For example, you could
+        #   specify `scheduling.automaticRestart = false` to include instances only if
+        #   they are not scheduled for automatic restarts. You can use filtering on nested
+        #   fields to filter based on resource labels. To filter on multiple expressions,
+        #   provide each separate expression within parentheses. For example: ``` (
+        #   scheduling.automaticRestart = true) (cpuPlatform = "Intel Skylake") ``` By
+        #   default, each expression is an `AND` expression. However, you can include `AND`
+        #   and `OR` expressions explicitly. For example: ``` (cpuPlatform = "Intel
+        #   Skylake") OR (cpuPlatform = "Intel Broadwell") AND (scheduling.
+        #   automaticRestart = true) ``` If you want to use a regular expression, use the `
+        #   eq` (equal) or `ne` (not equal) operator against a single un-parenthesized
+        #   expression with or without quotes or against multiple parenthesized
+        #   expressions. Examples: `fieldname eq unquoted literal` `fieldname eq 'single
+        #   quoted literal'` `fieldname eq "double quoted literal"` `(fieldname1 eq
+        #   literal) (fieldname2 ne "literal")` The literal value is interpreted as a
+        #   regular expression using Google RE2 library syntax. The literal value must
+        #   match the entire field. For example, to filter for instances that do not end
+        #   with name "instance", you would use `name ne .*instance`.
         # @param [Fixnum] max_results
         #   The maximum number of results per page that should be returned. If the number
         #   of available results is larger than `maxResults`, Compute Engine returns a `
@@ -484,25 +495,36 @@ module Google
         # @param [String] project
         #   The project ID for this request.
         # @param [String] filter
-        #   A filter expression that filters resources listed in the response. The
-        #   expression must specify the field name, an operator, and the value that you
-        #   want to use for filtering. The value must be a string, a number, or a boolean.
-        #   The operator must be either `=`, `!=`, `>`, `<`, `<=`, `>=` or `:`. For
-        #   example, if you are filtering Compute Engine instances, you can exclude
-        #   instances named `example-instance` by specifying `name != example-instance`.
-        #   The `:` operator can be used with string fields to match substrings. For non-
-        #   string fields it is equivalent to the `=` operator. The `:*` comparison can be
-        #   used to test whether a key has been defined. For example, to find all objects
-        #   with `owner` label use: ``` labels.owner:* ``` You can also filter nested
-        #   fields. For example, you could specify `scheduling.automaticRestart = false`
-        #   to include instances only if they are not scheduled for automatic restarts.
-        #   You can use filtering on nested fields to filter based on resource labels. To
-        #   filter on multiple expressions, provide each separate expression within
-        #   parentheses. For example: ``` (scheduling.automaticRestart = true) (
-        #   cpuPlatform = "Intel Skylake") ``` By default, each expression is an `AND`
-        #   expression. However, you can include `AND` and `OR` expressions explicitly.
-        #   For example: ``` (cpuPlatform = "Intel Skylake") OR (cpuPlatform = "Intel
-        #   Broadwell") AND (scheduling.automaticRestart = true) ```
+        #   A filter expression that filters resources listed in the response. Most
+        #   Compute resources support two types of filter expressions: expressions that
+        #   support regular expressions and expressions that follow API improvement
+        #   proposal AIP-160. If you want to use AIP-160, your expression must specify the
+        #   field name, an operator, and the value that you want to use for filtering. The
+        #   value must be a string, a number, or a boolean. The operator must be either `=`
+        #   , `!=`, `>`, `<`, `<=`, `>=` or `:`. For example, if you are filtering Compute
+        #   Engine instances, you can exclude instances named `example-instance` by
+        #   specifying `name != example-instance`. The `:` operator can be used with
+        #   string fields to match substrings. For non-string fields it is equivalent to
+        #   the `=` operator. The `:*` comparison can be used to test whether a key has
+        #   been defined. For example, to find all objects with `owner` label use: ```
+        #   labels.owner:* ``` You can also filter nested fields. For example, you could
+        #   specify `scheduling.automaticRestart = false` to include instances only if
+        #   they are not scheduled for automatic restarts. You can use filtering on nested
+        #   fields to filter based on resource labels. To filter on multiple expressions,
+        #   provide each separate expression within parentheses. For example: ``` (
+        #   scheduling.automaticRestart = true) (cpuPlatform = "Intel Skylake") ``` By
+        #   default, each expression is an `AND` expression. However, you can include `AND`
+        #   and `OR` expressions explicitly. For example: ``` (cpuPlatform = "Intel
+        #   Skylake") OR (cpuPlatform = "Intel Broadwell") AND (scheduling.
+        #   automaticRestart = true) ``` If you want to use a regular expression, use the `
+        #   eq` (equal) or `ne` (not equal) operator against a single un-parenthesized
+        #   expression with or without quotes or against multiple parenthesized
+        #   expressions. Examples: `fieldname eq unquoted literal` `fieldname eq 'single
+        #   quoted literal'` `fieldname eq "double quoted literal"` `(fieldname1 eq
+        #   literal) (fieldname2 ne "literal")` The literal value is interpreted as a
+        #   regular expression using Google RE2 library syntax. The literal value must
+        #   match the entire field. For example, to filter for instances that do not end
+        #   with name "instance", you would use `name ne .*instance`.
         # @param [Fixnum] max_results
         #   The maximum number of results per page that should be returned. If the number
         #   of available results is larger than `maxResults`, Compute Engine returns a `
@@ -812,25 +834,36 @@ module Google
         # @param [String] deployment
         #   The name of the deployment for this request.
         # @param [String] filter
-        #   A filter expression that filters resources listed in the response. The
-        #   expression must specify the field name, an operator, and the value that you
-        #   want to use for filtering. The value must be a string, a number, or a boolean.
-        #   The operator must be either `=`, `!=`, `>`, `<`, `<=`, `>=` or `:`. For
-        #   example, if you are filtering Compute Engine instances, you can exclude
-        #   instances named `example-instance` by specifying `name != example-instance`.
-        #   The `:` operator can be used with string fields to match substrings. For non-
-        #   string fields it is equivalent to the `=` operator. The `:*` comparison can be
-        #   used to test whether a key has been defined. For example, to find all objects
-        #   with `owner` label use: ``` labels.owner:* ``` You can also filter nested
-        #   fields. For example, you could specify `scheduling.automaticRestart = false`
-        #   to include instances only if they are not scheduled for automatic restarts.
-        #   You can use filtering on nested fields to filter based on resource labels. To
-        #   filter on multiple expressions, provide each separate expression within
-        #   parentheses. For example: ``` (scheduling.automaticRestart = true) (
-        #   cpuPlatform = "Intel Skylake") ``` By default, each expression is an `AND`
-        #   expression. However, you can include `AND` and `OR` expressions explicitly.
-        #   For example: ``` (cpuPlatform = "Intel Skylake") OR (cpuPlatform = "Intel
-        #   Broadwell") AND (scheduling.automaticRestart = true) ```
+        #   A filter expression that filters resources listed in the response. Most
+        #   Compute resources support two types of filter expressions: expressions that
+        #   support regular expressions and expressions that follow API improvement
+        #   proposal AIP-160. If you want to use AIP-160, your expression must specify the
+        #   field name, an operator, and the value that you want to use for filtering. The
+        #   value must be a string, a number, or a boolean. The operator must be either `=`
+        #   , `!=`, `>`, `<`, `<=`, `>=` or `:`. For example, if you are filtering Compute
+        #   Engine instances, you can exclude instances named `example-instance` by
+        #   specifying `name != example-instance`. The `:` operator can be used with
+        #   string fields to match substrings. For non-string fields it is equivalent to
+        #   the `=` operator. The `:*` comparison can be used to test whether a key has
+        #   been defined. For example, to find all objects with `owner` label use: ```
+        #   labels.owner:* ``` You can also filter nested fields. For example, you could
+        #   specify `scheduling.automaticRestart = false` to include instances only if
+        #   they are not scheduled for automatic restarts. You can use filtering on nested
+        #   fields to filter based on resource labels. To filter on multiple expressions,
+        #   provide each separate expression within parentheses. For example: ``` (
+        #   scheduling.automaticRestart = true) (cpuPlatform = "Intel Skylake") ``` By
+        #   default, each expression is an `AND` expression. However, you can include `AND`
+        #   and `OR` expressions explicitly. For example: ``` (cpuPlatform = "Intel
+        #   Skylake") OR (cpuPlatform = "Intel Broadwell") AND (scheduling.
+        #   automaticRestart = true) ``` If you want to use a regular expression, use the `
+        #   eq` (equal) or `ne` (not equal) operator against a single un-parenthesized
+        #   expression with or without quotes or against multiple parenthesized
+        #   expressions. Examples: `fieldname eq unquoted literal` `fieldname eq 'single
+        #   quoted literal'` `fieldname eq "double quoted literal"` `(fieldname1 eq
+        #   literal) (fieldname2 ne "literal")` The literal value is interpreted as a
+        #   regular expression using Google RE2 library syntax. The literal value must
+        #   match the entire field. For example, to filter for instances that do not end
+        #   with name "instance", you would use `name ne .*instance`.
         # @param [Fixnum] max_results
         #   The maximum number of results per page that should be returned. If the number
         #   of available results is larger than `maxResults`, Compute Engine returns a `
@@ -916,25 +949,36 @@ module Google
         # @param [String] project
         #   The project ID for this request.
         # @param [String] filter
-        #   A filter expression that filters resources listed in the response. The
-        #   expression must specify the field name, an operator, and the value that you
-        #   want to use for filtering. The value must be a string, a number, or a boolean.
-        #   The operator must be either `=`, `!=`, `>`, `<`, `<=`, `>=` or `:`. For
-        #   example, if you are filtering Compute Engine instances, you can exclude
-        #   instances named `example-instance` by specifying `name != example-instance`.
-        #   The `:` operator can be used with string fields to match substrings. For non-
-        #   string fields it is equivalent to the `=` operator. The `:*` comparison can be
-        #   used to test whether a key has been defined. For example, to find all objects
-        #   with `owner` label use: ``` labels.owner:* ``` You can also filter nested
-        #   fields. For example, you could specify `scheduling.automaticRestart = false`
-        #   to include instances only if they are not scheduled for automatic restarts.
-        #   You can use filtering on nested fields to filter based on resource labels. To
-        #   filter on multiple expressions, provide each separate expression within
-        #   parentheses. For example: ``` (scheduling.automaticRestart = true) (
-        #   cpuPlatform = "Intel Skylake") ``` By default, each expression is an `AND`
-        #   expression. However, you can include `AND` and `OR` expressions explicitly.
-        #   For example: ``` (cpuPlatform = "Intel Skylake") OR (cpuPlatform = "Intel
-        #   Broadwell") AND (scheduling.automaticRestart = true) ```
+        #   A filter expression that filters resources listed in the response. Most
+        #   Compute resources support two types of filter expressions: expressions that
+        #   support regular expressions and expressions that follow API improvement
+        #   proposal AIP-160. If you want to use AIP-160, your expression must specify the
+        #   field name, an operator, and the value that you want to use for filtering. The
+        #   value must be a string, a number, or a boolean. The operator must be either `=`
+        #   , `!=`, `>`, `<`, `<=`, `>=` or `:`. For example, if you are filtering Compute
+        #   Engine instances, you can exclude instances named `example-instance` by
+        #   specifying `name != example-instance`. The `:` operator can be used with
+        #   string fields to match substrings. For non-string fields it is equivalent to
+        #   the `=` operator. The `:*` comparison can be used to test whether a key has
+        #   been defined. For example, to find all objects with `owner` label use: ```
+        #   labels.owner:* ``` You can also filter nested fields. For example, you could
+        #   specify `scheduling.automaticRestart = false` to include instances only if
+        #   they are not scheduled for automatic restarts. You can use filtering on nested
+        #   fields to filter based on resource labels. To filter on multiple expressions,
+        #   provide each separate expression within parentheses. For example: ``` (
+        #   scheduling.automaticRestart = true) (cpuPlatform = "Intel Skylake") ``` By
+        #   default, each expression is an `AND` expression. However, you can include `AND`
+        #   and `OR` expressions explicitly. For example: ``` (cpuPlatform = "Intel
+        #   Skylake") OR (cpuPlatform = "Intel Broadwell") AND (scheduling.
+        #   automaticRestart = true) ``` If you want to use a regular expression, use the `
+        #   eq` (equal) or `ne` (not equal) operator against a single un-parenthesized
+        #   expression with or without quotes or against multiple parenthesized
+        #   expressions. Examples: `fieldname eq unquoted literal` `fieldname eq 'single
+        #   quoted literal'` `fieldname eq "double quoted literal"` `(fieldname1 eq
+        #   literal) (fieldname2 ne "literal")` The literal value is interpreted as a
+        #   regular expression using Google RE2 library syntax. The literal value must
+        #   match the entire field. For example, to filter for instances that do not end
+        #   with name "instance", you would use `name ne .*instance`.
         # @param [Fixnum] max_results
         #   The maximum number of results per page that should be returned. If the number
         #   of available results is larger than `maxResults`, Compute Engine returns a `
@@ -1024,25 +1068,36 @@ module Google
         # @param [String] deployment
         #   The name of the deployment for this request.
         # @param [String] filter
-        #   A filter expression that filters resources listed in the response. The
-        #   expression must specify the field name, an operator, and the value that you
-        #   want to use for filtering. The value must be a string, a number, or a boolean.
-        #   The operator must be either `=`, `!=`, `>`, `<`, `<=`, `>=` or `:`. For
-        #   example, if you are filtering Compute Engine instances, you can exclude
-        #   instances named `example-instance` by specifying `name != example-instance`.
-        #   The `:` operator can be used with string fields to match substrings. For non-
-        #   string fields it is equivalent to the `=` operator. The `:*` comparison can be
-        #   used to test whether a key has been defined. For example, to find all objects
-        #   with `owner` label use: ``` labels.owner:* ``` You can also filter nested
-        #   fields. For example, you could specify `scheduling.automaticRestart = false`
-        #   to include instances only if they are not scheduled for automatic restarts.
-        #   You can use filtering on nested fields to filter based on resource labels. To
-        #   filter on multiple expressions, provide each separate expression within
-        #   parentheses. For example: ``` (scheduling.automaticRestart = true) (
-        #   cpuPlatform = "Intel Skylake") ``` By default, each expression is an `AND`
-        #   expression. However, you can include `AND` and `OR` expressions explicitly.
-        #   For example: ``` (cpuPlatform = "Intel Skylake") OR (cpuPlatform = "Intel
-        #   Broadwell") AND (scheduling.automaticRestart = true) ```
+        #   A filter expression that filters resources listed in the response. Most
+        #   Compute resources support two types of filter expressions: expressions that
+        #   support regular expressions and expressions that follow API improvement
+        #   proposal AIP-160. If you want to use AIP-160, your expression must specify the
+        #   field name, an operator, and the value that you want to use for filtering. The
+        #   value must be a string, a number, or a boolean. The operator must be either `=`
+        #   , `!=`, `>`, `<`, `<=`, `>=` or `:`. For example, if you are filtering Compute
+        #   Engine instances, you can exclude instances named `example-instance` by
+        #   specifying `name != example-instance`. The `:` operator can be used with
+        #   string fields to match substrings. For non-string fields it is equivalent to
+        #   the `=` operator. The `:*` comparison can be used to test whether a key has
+        #   been defined. For example, to find all objects with `owner` label use: ```
+        #   labels.owner:* ``` You can also filter nested fields. For example, you could
+        #   specify `scheduling.automaticRestart = false` to include instances only if
+        #   they are not scheduled for automatic restarts. You can use filtering on nested
+        #   fields to filter based on resource labels. To filter on multiple expressions,
+        #   provide each separate expression within parentheses. For example: ``` (
+        #   scheduling.automaticRestart = true) (cpuPlatform = "Intel Skylake") ``` By
+        #   default, each expression is an `AND` expression. However, you can include `AND`
+        #   and `OR` expressions explicitly. For example: ``` (cpuPlatform = "Intel
+        #   Skylake") OR (cpuPlatform = "Intel Broadwell") AND (scheduling.
+        #   automaticRestart = true) ``` If you want to use a regular expression, use the `
+        #   eq` (equal) or `ne` (not equal) operator against a single un-parenthesized
+        #   expression with or without quotes or against multiple parenthesized
+        #   expressions. Examples: `fieldname eq unquoted literal` `fieldname eq 'single
+        #   quoted literal'` `fieldname eq "double quoted literal"` `(fieldname1 eq
+        #   literal) (fieldname2 ne "literal")` The literal value is interpreted as a
+        #   regular expression using Google RE2 library syntax. The literal value must
+        #   match the entire field. For example, to filter for instances that do not end
+        #   with name "instance", you would use `name ne .*instance`.
         # @param [Fixnum] max_results
         #   The maximum number of results per page that should be returned. If the number
         #   of available results is larger than `maxResults`, Compute Engine returns a `
@@ -1230,25 +1285,36 @@ module Google
         # @param [String] project
         #   The project ID for this request.
         # @param [String] filter
-        #   A filter expression that filters resources listed in the response. The
-        #   expression must specify the field name, an operator, and the value that you
-        #   want to use for filtering. The value must be a string, a number, or a boolean.
-        #   The operator must be either `=`, `!=`, `>`, `<`, `<=`, `>=` or `:`. For
-        #   example, if you are filtering Compute Engine instances, you can exclude
-        #   instances named `example-instance` by specifying `name != example-instance`.
-        #   The `:` operator can be used with string fields to match substrings. For non-
-        #   string fields it is equivalent to the `=` operator. The `:*` comparison can be
-        #   used to test whether a key has been defined. For example, to find all objects
-        #   with `owner` label use: ``` labels.owner:* ``` You can also filter nested
-        #   fields. For example, you could specify `scheduling.automaticRestart = false`
-        #   to include instances only if they are not scheduled for automatic restarts.
-        #   You can use filtering on nested fields to filter based on resource labels. To
-        #   filter on multiple expressions, provide each separate expression within
-        #   parentheses. For example: ``` (scheduling.automaticRestart = true) (
-        #   cpuPlatform = "Intel Skylake") ``` By default, each expression is an `AND`
-        #   expression. However, you can include `AND` and `OR` expressions explicitly.
-        #   For example: ``` (cpuPlatform = "Intel Skylake") OR (cpuPlatform = "Intel
-        #   Broadwell") AND (scheduling.automaticRestart = true) ```
+        #   A filter expression that filters resources listed in the response. Most
+        #   Compute resources support two types of filter expressions: expressions that
+        #   support regular expressions and expressions that follow API improvement
+        #   proposal AIP-160. If you want to use AIP-160, your expression must specify the
+        #   field name, an operator, and the value that you want to use for filtering. The
+        #   value must be a string, a number, or a boolean. The operator must be either `=`
+        #   , `!=`, `>`, `<`, `<=`, `>=` or `:`. For example, if you are filtering Compute
+        #   Engine instances, you can exclude instances named `example-instance` by
+        #   specifying `name != example-instance`. The `:` operator can be used with
+        #   string fields to match substrings. For non-string fields it is equivalent to
+        #   the `=` operator. The `:*` comparison can be used to test whether a key has
+        #   been defined. For example, to find all objects with `owner` label use: ```
+        #   labels.owner:* ``` You can also filter nested fields. For example, you could
+        #   specify `scheduling.automaticRestart = false` to include instances only if
+        #   they are not scheduled for automatic restarts. You can use filtering on nested
+        #   fields to filter based on resource labels. To filter on multiple expressions,
+        #   provide each separate expression within parentheses. For example: ``` (
+        #   scheduling.automaticRestart = true) (cpuPlatform = "Intel Skylake") ``` By
+        #   default, each expression is an `AND` expression. However, you can include `AND`
+        #   and `OR` expressions explicitly. For example: ``` (cpuPlatform = "Intel
+        #   Skylake") OR (cpuPlatform = "Intel Broadwell") AND (scheduling.
+        #   automaticRestart = true) ``` If you want to use a regular expression, use the `
+        #   eq` (equal) or `ne` (not equal) operator against a single un-parenthesized
+        #   expression with or without quotes or against multiple parenthesized
+        #   expressions. Examples: `fieldname eq unquoted literal` `fieldname eq 'single
+        #   quoted literal'` `fieldname eq "double quoted literal"` `(fieldname1 eq
+        #   literal) (fieldname2 ne "literal")` The literal value is interpreted as a
+        #   regular expression using Google RE2 library syntax. The literal value must
+        #   match the entire field. For example, to filter for instances that do not end
+        #   with name "instance", you would use `name ne .*instance`.
         # @param [Fixnum] max_results
         #   The maximum number of results per page that should be returned. If the number
         #   of available results is larger than `maxResults`, Compute Engine returns a `
@@ -1302,25 +1368,36 @@ module Google
         # @param [String] type_provider
         #   The name of the type provider for this request.
         # @param [String] filter
-        #   A filter expression that filters resources listed in the response. The
-        #   expression must specify the field name, an operator, and the value that you
-        #   want to use for filtering. The value must be a string, a number, or a boolean.
-        #   The operator must be either `=`, `!=`, `>`, `<`, `<=`, `>=` or `:`. For
-        #   example, if you are filtering Compute Engine instances, you can exclude
-        #   instances named `example-instance` by specifying `name != example-instance`.
-        #   The `:` operator can be used with string fields to match substrings. For non-
-        #   string fields it is equivalent to the `=` operator. The `:*` comparison can be
-        #   used to test whether a key has been defined. For example, to find all objects
-        #   with `owner` label use: ``` labels.owner:* ``` You can also filter nested
-        #   fields. For example, you could specify `scheduling.automaticRestart = false`
-        #   to include instances only if they are not scheduled for automatic restarts.
-        #   You can use filtering on nested fields to filter based on resource labels. To
-        #   filter on multiple expressions, provide each separate expression within
-        #   parentheses. For example: ``` (scheduling.automaticRestart = true) (
-        #   cpuPlatform = "Intel Skylake") ``` By default, each expression is an `AND`
-        #   expression. However, you can include `AND` and `OR` expressions explicitly.
-        #   For example: ``` (cpuPlatform = "Intel Skylake") OR (cpuPlatform = "Intel
-        #   Broadwell") AND (scheduling.automaticRestart = true) ```
+        #   A filter expression that filters resources listed in the response. Most
+        #   Compute resources support two types of filter expressions: expressions that
+        #   support regular expressions and expressions that follow API improvement
+        #   proposal AIP-160. If you want to use AIP-160, your expression must specify the
+        #   field name, an operator, and the value that you want to use for filtering. The
+        #   value must be a string, a number, or a boolean. The operator must be either `=`
+        #   , `!=`, `>`, `<`, `<=`, `>=` or `:`. For example, if you are filtering Compute
+        #   Engine instances, you can exclude instances named `example-instance` by
+        #   specifying `name != example-instance`. The `:` operator can be used with
+        #   string fields to match substrings. For non-string fields it is equivalent to
+        #   the `=` operator. The `:*` comparison can be used to test whether a key has
+        #   been defined. For example, to find all objects with `owner` label use: ```
+        #   labels.owner:* ``` You can also filter nested fields. For example, you could
+        #   specify `scheduling.automaticRestart = false` to include instances only if
+        #   they are not scheduled for automatic restarts. You can use filtering on nested
+        #   fields to filter based on resource labels. To filter on multiple expressions,
+        #   provide each separate expression within parentheses. For example: ``` (
+        #   scheduling.automaticRestart = true) (cpuPlatform = "Intel Skylake") ``` By
+        #   default, each expression is an `AND` expression. However, you can include `AND`
+        #   and `OR` expressions explicitly. For example: ``` (cpuPlatform = "Intel
+        #   Skylake") OR (cpuPlatform = "Intel Broadwell") AND (scheduling.
+        #   automaticRestart = true) ``` If you want to use a regular expression, use the `
+        #   eq` (equal) or `ne` (not equal) operator against a single un-parenthesized
+        #   expression with or without quotes or against multiple parenthesized
+        #   expressions. Examples: `fieldname eq unquoted literal` `fieldname eq 'single
+        #   quoted literal'` `fieldname eq "double quoted literal"` `(fieldname1 eq
+        #   literal) (fieldname2 ne "literal")` The literal value is interpreted as a
+        #   regular expression using Google RE2 library syntax. The literal value must
+        #   match the entire field. For example, to filter for instances that do not end
+        #   with name "instance", you would use `name ne .*instance`.
         # @param [Fixnum] max_results
         #   The maximum number of results per page that should be returned. If the number
         #   of available results is larger than `maxResults`, Compute Engine returns a `
@@ -1445,25 +1522,36 @@ module Google
         # @param [String] project
         #   The project ID for this request.
         # @param [String] filter
-        #   A filter expression that filters resources listed in the response. The
-        #   expression must specify the field name, an operator, and the value that you
-        #   want to use for filtering. The value must be a string, a number, or a boolean.
-        #   The operator must be either `=`, `!=`, `>`, `<`, `<=`, `>=` or `:`. For
-        #   example, if you are filtering Compute Engine instances, you can exclude
-        #   instances named `example-instance` by specifying `name != example-instance`.
-        #   The `:` operator can be used with string fields to match substrings. For non-
-        #   string fields it is equivalent to the `=` operator. The `:*` comparison can be
-        #   used to test whether a key has been defined. For example, to find all objects
-        #   with `owner` label use: ``` labels.owner:* ``` You can also filter nested
-        #   fields. For example, you could specify `scheduling.automaticRestart = false`
-        #   to include instances only if they are not scheduled for automatic restarts.
-        #   You can use filtering on nested fields to filter based on resource labels. To
-        #   filter on multiple expressions, provide each separate expression within
-        #   parentheses. For example: ``` (scheduling.automaticRestart = true) (
-        #   cpuPlatform = "Intel Skylake") ``` By default, each expression is an `AND`
-        #   expression. However, you can include `AND` and `OR` expressions explicitly.
-        #   For example: ``` (cpuPlatform = "Intel Skylake") OR (cpuPlatform = "Intel
-        #   Broadwell") AND (scheduling.automaticRestart = true) ```
+        #   A filter expression that filters resources listed in the response. Most
+        #   Compute resources support two types of filter expressions: expressions that
+        #   support regular expressions and expressions that follow API improvement
+        #   proposal AIP-160. If you want to use AIP-160, your expression must specify the
+        #   field name, an operator, and the value that you want to use for filtering. The
+        #   value must be a string, a number, or a boolean. The operator must be either `=`
+        #   , `!=`, `>`, `<`, `<=`, `>=` or `:`. For example, if you are filtering Compute
+        #   Engine instances, you can exclude instances named `example-instance` by
+        #   specifying `name != example-instance`. The `:` operator can be used with
+        #   string fields to match substrings. For non-string fields it is equivalent to
+        #   the `=` operator. The `:*` comparison can be used to test whether a key has
+        #   been defined. For example, to find all objects with `owner` label use: ```
+        #   labels.owner:* ``` You can also filter nested fields. For example, you could
+        #   specify `scheduling.automaticRestart = false` to include instances only if
+        #   they are not scheduled for automatic restarts. You can use filtering on nested
+        #   fields to filter based on resource labels. To filter on multiple expressions,
+        #   provide each separate expression within parentheses. For example: ``` (
+        #   scheduling.automaticRestart = true) (cpuPlatform = "Intel Skylake") ``` By
+        #   default, each expression is an `AND` expression. However, you can include `AND`
+        #   and `OR` expressions explicitly. For example: ``` (cpuPlatform = "Intel
+        #   Skylake") OR (cpuPlatform = "Intel Broadwell") AND (scheduling.
+        #   automaticRestart = true) ``` If you want to use a regular expression, use the `
+        #   eq` (equal) or `ne` (not equal) operator against a single un-parenthesized
+        #   expression with or without quotes or against multiple parenthesized
+        #   expressions. Examples: `fieldname eq unquoted literal` `fieldname eq 'single
+        #   quoted literal'` `fieldname eq "double quoted literal"` `(fieldname1 eq
+        #   literal) (fieldname2 ne "literal")` The literal value is interpreted as a
+        #   regular expression using Google RE2 library syntax. The literal value must
+        #   match the entire field. For example, to filter for instances that do not end
+        #   with name "instance", you would use `name ne .*instance`.
         # @param [Fixnum] max_results
         #   The maximum number of results per page that should be returned. If the number
         #   of available results is larger than `maxResults`, Compute Engine returns a `

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: google-apis-deploymentmanager_v2beta
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Google LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-18 00:00:00.000000000 Z
+date: 2022-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-apis-core
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
     - - "<"
       - !ruby/object:Gem::Version
         version: 2.a
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
     - - "<"
       - !ruby/object:Gem::Version
         version: 2.a
@@ -58,7 +58,7 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/googleapis/google-api-ruby-client/issues
   changelog_uri: https://github.com/googleapis/google-api-ruby-client/tree/main/generated/google-apis-deploymentmanager_v2beta/CHANGELOG.md
-  documentation_uri: https://googleapis.dev/ruby/google-apis-deploymentmanager_v2beta/v0.14.0
+  documentation_uri: https://googleapis.dev/ruby/google-apis-deploymentmanager_v2beta/v0.17.0
   source_code_uri: https://github.com/googleapis/google-api-ruby-client/tree/main/generated/google-apis-deploymentmanager_v2beta
 post_install_message: 
 rdoc_options: []
@@ -75,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
+rubygems_version: 3.3.14
 signing_key: 
 specification_version: 4
 summary: Simple REST client for Cloud Deployment Manager V2 API V2beta