feat: Automated regeneration of Compute client (googleapis#12468)

Auto-created at 2024-11-03 13:09:02 +0000 using the toys pull request generator.

Author: yoshi-code-bot

clients/compute/README.md

@@ -11,7 +11,7 @@ Install this package from [Hex](https://hex.pm) by adding
 
 ```elixir
 def deps do
-  [{:google_api_compute, "~> 0.67"}]
+  [{:google_api_compute, "~> 0.68"}]
 end
 ```
 

clients/compute/lib/google_api/compute/v1/api/instances.ex

@@ -3613,7 +3613,7 @@ defmodule GoogleApi.Compute.V1.Api.Instances do
       *   `:upload_protocol` (*type:* `String.t`) - Upload protocol for media (e.g. "raw", "multipart").
       *   `:userIp` (*type:* `String.t`) - Legacy name for parameter that has been superseded by `quotaUser`.
       *   `:port` (*type:* `integer()`) - Specifies which COM or serial port to retrieve data from.
-      *   `:start` (*type:* `String.t`) - Specifies the starting byte position of the output to return. To start with the first byte of output to the specified port, omit this field or set it to `0`. If the output for that byte position is available, this field matches the `start` parameter sent with the request. If the amount of serial console output exceeds the size of the buffer (1 MB), the oldest output is discarded and is no longer available. If the requested start position refers to discarded output, the start position is adjusted to the oldest output still available, and the adjusted start position is returned as the `start` property value. You can also provide a negative start position, which translates to the most recent number of bytes written to the serial port. For example, -3 is interpreted as the most recent 3 bytes written to the serial console.
+      *   `:start` (*type:* `String.t`) - Specifies the starting byte position of the output to return. To start with the first byte of output to the specified port, omit this field or set it to `0`. If the output for that byte position is available, this field matches the `start` parameter sent with the request. If the amount of serial console output exceeds the size of the buffer (1 MB), the oldest output is discarded and is no longer available. If the requested start position refers to discarded output, the start position is adjusted to the oldest output still available, and the adjusted start position is returned as the `start` property value. You can also provide a negative start position, which translates to the most recent number of bytes written to the serial port. For example, -3 is interpreted as the most recent 3 bytes written to the serial console. Note that the negative start is bounded by the retained buffer size, and the returned serial console output will not exceed the max buffer size.
   *   `opts` (*type:* `keyword()`) - Call options
 
   ## Returns

clients/compute/lib/google_api/compute/v1/metadata.ex

@@ -20,7 +20,7 @@ defmodule GoogleApi.Compute.V1 do
   API client metadata for GoogleApi.Compute.V1.
   """
 
-  @discovery_revision "20241015"
+  @discovery_revision "20241021"
 
   def discovery_revision(), do: @discovery_revision
 end

clients/compute/lib/google_api/compute/v1/model/backend_bucket_cdn_policy.ex

@@ -23,7 +23,7 @@ defmodule GoogleApi.Compute.V1.Model.BackendBucketCdnPolicy do
 
   *   `bypassCacheOnRequestHeaders` (*type:* `list(GoogleApi.Compute.V1.Model.BackendBucketCdnPolicyBypassCacheOnRequestHeader.t)`, *default:* `nil`) - Bypass the cache when the specified request headers are matched - e.g. Pragma or Authorization headers. Up to 5 headers can be specified. The cache is bypassed for all cdnPolicy.cacheMode settings.
   *   `cacheKeyPolicy` (*type:* `GoogleApi.Compute.V1.Model.BackendBucketCdnPolicyCacheKeyPolicy.t`, *default:* `nil`) - The CacheKeyPolicy for this CdnPolicy.
-  *   `cacheMode` (*type:* `String.t`, *default:* `nil`) - Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached.
+  *   `cacheMode` (*type:* `String.t`, *default:* `nil`) - Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached. If no value is provided for cdnPolicy.cacheMode, it defaults to CACHE_ALL_STATIC.
   *   `clientTtl` (*type:* `integer()`, *default:* `nil`) - Specifies a separate client (e.g. browser client) maximum TTL. This is used to clamp the max-age (or Expires) value sent to the client. With FORCE_CACHE_ALL, the lesser of client_ttl and default_ttl is used for the response max-age directive, along with a "public" directive. For cacheable content in CACHE_ALL_STATIC mode, client_ttl clamps the max-age from the origin (if specified), or else sets the response max-age directive to the lesser of the client_ttl and default_ttl, and also ensures a "public" cache-control directive is present. If a client TTL is not specified, a default value (1 hour) will be used. The maximum allowed value is 31,622,400s (1 year).
   *   `defaultTtl` (*type:* `integer()`, *default:* `nil`) - Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age). Setting a TTL of "0" means "always revalidate". The value of defaultTTL cannot be set to a value greater than that of maxTTL, but can be equal. When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses. The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
   *   `maxTtl` (*type:* `integer()`, *default:* `nil`) - Specifies the maximum allowed TTL for cached content served by this origin. Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTTL seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive. Headers sent to the client will not be modified. Setting a TTL of "0" means "always revalidate". The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.

clients/compute/lib/google_api/compute/v1/model/backend_service_cdn_policy.ex

@@ -23,7 +23,7 @@ defmodule GoogleApi.Compute.V1.Model.BackendServiceCdnPolicy do
 
   *   `bypassCacheOnRequestHeaders` (*type:* `list(GoogleApi.Compute.V1.Model.BackendServiceCdnPolicyBypassCacheOnRequestHeader.t)`, *default:* `nil`) - Bypass the cache when the specified request headers are matched - e.g. Pragma or Authorization headers. Up to 5 headers can be specified. The cache is bypassed for all cdnPolicy.cacheMode settings.
   *   `cacheKeyPolicy` (*type:* `GoogleApi.Compute.V1.Model.CacheKeyPolicy.t`, *default:* `nil`) - The CacheKeyPolicy for this CdnPolicy.
-  *   `cacheMode` (*type:* `String.t`, *default:* `nil`) - Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached.
+  *   `cacheMode` (*type:* `String.t`, *default:* `nil`) - Specifies the cache setting for all responses from this backend. The possible values are: USE_ORIGIN_HEADERS Requires the origin to set valid caching headers to cache content. Responses without these headers will not be cached at Google's edge, and will require a full trip to the origin on every request, potentially impacting performance and increasing load on the origin server. FORCE_CACHE_ALL Cache all content, ignoring any "private", "no-store" or "no-cache" directives in Cache-Control response headers. Warning: this may result in Cloud CDN caching private, per-user (user identifiable) content. CACHE_ALL_STATIC Automatically cache static content, including common image formats, media (video and audio), and web assets (JavaScript and CSS). Requests and responses that are marked as uncacheable, as well as dynamic content (including HTML), will not be cached. If no value is provided for cdnPolicy.cacheMode, it defaults to CACHE_ALL_STATIC.
   *   `clientTtl` (*type:* `integer()`, *default:* `nil`) - Specifies a separate client (e.g. browser client) maximum TTL. This is used to clamp the max-age (or Expires) value sent to the client. With FORCE_CACHE_ALL, the lesser of client_ttl and default_ttl is used for the response max-age directive, along with a "public" directive. For cacheable content in CACHE_ALL_STATIC mode, client_ttl clamps the max-age from the origin (if specified), or else sets the response max-age directive to the lesser of the client_ttl and default_ttl, and also ensures a "public" cache-control directive is present. If a client TTL is not specified, a default value (1 hour) will be used. The maximum allowed value is 31,622,400s (1 year).
   *   `defaultTtl` (*type:* `integer()`, *default:* `nil`) - Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age). Setting a TTL of "0" means "always revalidate". The value of defaultTTL cannot be set to a value greater than that of maxTTL, but can be equal. When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses. The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.
   *   `maxTtl` (*type:* `integer()`, *default:* `nil`) - Specifies the maximum allowed TTL for cached content served by this origin. Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTTL seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive. Headers sent to the client will not be modified. Setting a TTL of "0" means "always revalidate". The maximum allowed value is 31,622,400s (1 year), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.

clients/compute/lib/google_api/compute/v1/model/network_routing_config.ex

@@ -21,15 +21,24 @@ defmodule GoogleApi.Compute.V1.Model.NetworkRoutingConfig do
 
   ## Attributes
 
+  *   `bgpAlwaysCompareMed` (*type:* `boolean()`, *default:* `nil`) - Enable comparison of Multi-Exit Discriminators (MED) across routes with different neighbor ASNs when using the STANDARD BGP best path selection algorithm.
+  *   `bgpBestPathSelectionMode` (*type:* `String.t`, *default:* `nil`) - The BGP best path selection algorithm to be employed within this network for dynamic routes learned by Cloud Routers. Can be LEGACY (default) or STANDARD.
+  *   `bgpInterRegionCost` (*type:* `String.t`, *default:* `nil`) - Allows to define a preferred approach for handling inter-region cost in the selection process when using the STANDARD BGP best path selection algorithm. Can be DEFAULT or ADD_COST_TO_MED.
   *   `routingMode` (*type:* `String.t`, *default:* `nil`) - The network-wide routing mode to use. If set to REGIONAL, this network's Cloud Routers will only advertise routes with subnets of this network in the same region as the router. If set to GLOBAL, this network's Cloud Routers will advertise routes with all subnets of this network, across regions.
   """
 
   use GoogleApi.Gax.ModelBase
 
   @type t :: %__MODULE__{
+          :bgpAlwaysCompareMed => boolean() | nil,
+          :bgpBestPathSelectionMode => String.t() | nil,
+          :bgpInterRegionCost => String.t() | nil,
           :routingMode => String.t() | nil
         }
 
+  field(:bgpAlwaysCompareMed)
+  field(:bgpBestPathSelectionMode)
+  field(:bgpInterRegionCost)
   field(:routingMode)
 end
 

clients/compute/lib/google_api/compute/v1/model/route.ex

@@ -33,8 +33,11 @@ defmodule GoogleApi.Compute.V1.Model.Route do
   *   `nextHopHub` (*type:* `String.t`, *default:* `nil`) - [Output Only] The full resource name of the Network Connectivity Center hub that will handle matching packets.
   *   `nextHopIlb` (*type:* `String.t`, *default:* `nil`) - The URL to a forwarding rule of type loadBalancingScheme=INTERNAL that should handle matching packets or the IP address of the forwarding Rule. For example, the following are all valid URLs: - https://www.googleapis.com/compute/v1/projects/project/regions/region /forwardingRules/forwardingRule - regions/region/forwardingRules/forwardingRule If an IP address is provided, must specify an IPv4 address in dot-decimal notation or an IPv6 address in RFC 4291 format. For example, the following are all valid IP addresses: - 10.128.0.56 - 2001:db8::2d9:51:0:0 - 2001:db8:0:0:2d9:51:0:0 IPv6 addresses will be displayed using RFC 5952 compressed format (e.g. 2001:db8::2d9:51:0:0). Should never be an IPv4-mapped IPv6 address.
   *   `nextHopInstance` (*type:* `String.t`, *default:* `nil`) - The URL to an instance that should handle matching packets. You can specify this as a full or partial URL. For example: https://www.googleapis.com/compute/v1/projects/project/zones/zone/instances/
+  *   `nextHopInterRegionCost` (*type:* `integer()`, *default:* `nil`) - [Output only] Internal fixed region-to-region cost that Google Cloud calculates based on factors such as network performance, distance, and available bandwidth between regions.
   *   `nextHopIp` (*type:* `String.t`, *default:* `nil`) - The network IP address of an instance that should handle matching packets. Both IPv6 address and IPv4 addresses are supported. Must specify an IPv4 address in dot-decimal notation (e.g. 192.0.2.99) or an IPv6 address in RFC 4291 format (e.g. 2001:db8::2d9:51:0:0 or 2001:db8:0:0:2d9:51:0:0). IPv6 addresses will be displayed using RFC 5952 compressed format (e.g. 2001:db8::2d9:51:0:0). Should never be an IPv4-mapped IPv6 address.
+  *   `nextHopMed` (*type:* `integer()`, *default:* `nil`) - [Output Only] Multi-Exit Discriminator, a BGP route metric that indicates the desirability of a particular route in a network.
   *   `nextHopNetwork` (*type:* `String.t`, *default:* `nil`) - The URL of the local network if it should handle matching packets.
+  *   `nextHopOrigin` (*type:* `String.t`, *default:* `nil`) - [Output Only] Indicates the origin of the route. Can be IGP (Interior Gateway Protocol), EGP (Exterior Gateway Protocol), or INCOMPLETE.
   *   `nextHopPeering` (*type:* `String.t`, *default:* `nil`) - [Output Only] The network peering name that should handle matching packets, which should conform to RFC1035.
   *   `nextHopVpnTunnel` (*type:* `String.t`, *default:* `nil`) - The URL to a VpnTunnel that should handle matching packets.
   *   `priority` (*type:* `integer()`, *default:* `nil`) - The priority of this route. Priority is used to break ties in cases where there is more than one matching route of equal prefix length. In cases where multiple routes have equal prefix length, the one with the lowest-numbered priority value wins. The default value is `1000`. The priority value must be from `0` to `65535`, inclusive.
@@ -60,8 +63,11 @@ defmodule GoogleApi.Compute.V1.Model.Route do
           :nextHopHub => String.t() | nil,
           :nextHopIlb => String.t() | nil,
           :nextHopInstance => String.t() | nil,
+          :nextHopInterRegionCost => integer() | nil,
           :nextHopIp => String.t() | nil,
+          :nextHopMed => integer() | nil,
           :nextHopNetwork => String.t() | nil,
+          :nextHopOrigin => String.t() | nil,
           :nextHopPeering => String.t() | nil,
           :nextHopVpnTunnel => String.t() | nil,
           :priority => integer() | nil,
@@ -84,8 +90,11 @@ defmodule GoogleApi.Compute.V1.Model.Route do
   field(:nextHopHub)
   field(:nextHopIlb)
   field(:nextHopInstance)
+  field(:nextHopInterRegionCost)
   field(:nextHopIp)
+  field(:nextHopMed)
   field(:nextHopNetwork)
+  field(:nextHopOrigin)
   field(:nextHopPeering)
   field(:nextHopVpnTunnel)
   field(:priority)