google-apis-deploymentmanager_v2 0.25.0 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4194efbf16e5d6880353950bd1d28effc494f9d03699f41325aae391c91693ee
-  data.tar.gz: e57edb80edb62c6b8bf729d068227a219959d30ff6c5cd34d3188e4708b69e6a
+  metadata.gz: eb509ed5f0c956c5834b73855a307b7b02ef7d1c356d0527c74fb96ffb8bf00d
+  data.tar.gz: 2c6530415ce2cd74c8e1a15bd1e6210fd4ff3fb5cb85c323b4dde1c91584eda3
 SHA512:
-  metadata.gz: f721c2199fd874f0501f0b6c31b121f788b0e41d4c2eddd4e756e731a7093b9697c80669c0249633aaa0d95f124b1ec00bb668821fbe5bacf0eaa0038b875823
-  data.tar.gz: 9f8613c65b1853880086d333e196709280f69919983cf540a0cac259dcbcbf598779b6a64060bf5e0974239d4a8776225f9075dd946dcb611f1c6868ccc1a1b6
+  metadata.gz: 9fef573db80f41066009f1b69807c12fbe442f8358ef17cb40669bab5bcc8c58d84dea8e2f6788768efbf797a5f3bf58477fc16f528797143c206233708092fa
+  data.tar.gz: 49a18b84fd607c0d43d3c4666f73fc88c0b5fa7416357d7d36e033215546b4ada6215c054b1ffd80ce822410e96f3579ec2ffd2726e1069f737b9adc347b5e0c

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Release history for google-apis-deploymentmanager_v2
 
+### v0.26.0 (2023-10-01)
+
+* Regenerated from discovery document revision 20230921
+
 ### v0.25.0 (2023-08-27)
 
 * Regenerated from discovery document revision 20230821

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

@@ -16,13 +16,13 @@ module Google
   module Apis
     module DeploymentmanagerV2
       # Version of the google-apis-deploymentmanager_v2 gem
-      GEM_VERSION = "0.25.0"
+      GEM_VERSION = "0.26.0"
 
       # Version of the code generator used to generate this client
       GENERATOR_VERSION = "0.12.0"
 
       # Revision of the discovery document this client was generated from
-      REVISION = "20230821"
+      REVISION = "20230921"
     end
   end
 end

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

@@ -246,33 +246,34 @@ module Google
         #   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
+        #   proposal AIP-160. These two types of filter expressions cannot be mixed in one
+        #   request. 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`.
+        #   specifying `name != example-instance`. 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`. You cannot combine constraints on multiple fields using regular
+        #   expressions.
         # @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 `
@@ -585,33 +586,34 @@ module Google
         #   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
+        #   proposal AIP-160. These two types of filter expressions cannot be mixed in one
+        #   request. 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`.
+        #   specifying `name != example-instance`. 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`. You cannot combine constraints on multiple fields using regular
+        #   expressions.
         # @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 `
@@ -700,33 +702,34 @@ module Google
         #   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
+        #   proposal AIP-160. These two types of filter expressions cannot be mixed in one
+        #   request. 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`.
+        #   specifying `name != example-instance`. 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`. You cannot combine constraints on multiple fields using regular
+        #   expressions.
         # @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 `
@@ -819,33 +822,34 @@ module Google
         #   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
+        #   proposal AIP-160. These two types of filter expressions cannot be mixed in one
+        #   request. 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`.
+        #   specifying `name != example-instance`. 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`. You cannot combine constraints on multiple fields using regular
+        #   expressions.
         # @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 `
@@ -901,33 +905,34 @@ module Google
         #   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
+        #   proposal AIP-160. These two types of filter expressions cannot be mixed in one
+        #   request. 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`.
+        #   specifying `name != example-instance`. 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`. You cannot combine constraints on multiple fields using regular
+        #   expressions.
         # @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_v2
 version: !ruby/object:Gem::Version
-  version: 0.25.0
+  version: 0.26.0
 platform: ruby
 authors:
 - Google LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-27 00:00:00.000000000 Z
+date: 2023-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-apis-core
@@ -58,7 +58,7 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/googleapis/google-api-ruby-client/issues
   changelog_uri: https://github.com/googleapis/google-api-ruby-client/tree/main/generated/google-apis-deploymentmanager_v2/CHANGELOG.md
-  documentation_uri: https://googleapis.dev/ruby/google-apis-deploymentmanager_v2/v0.25.0
+  documentation_uri: https://googleapis.dev/ruby/google-apis-deploymentmanager_v2/v0.26.0
   source_code_uri: https://github.com/googleapis/google-api-ruby-client/tree/main/generated/google-apis-deploymentmanager_v2
 post_install_message: 
 rdoc_options: []