Regenerate compute client (#8464)

Generated in GitHub action: https://togithub.com/googleapis/googleapis/google-api-php-client-services/actions/workflows/codegen.yaml

Author: yoshi-code-bot

src/Compute/CachePolicy.php

@@ -0,0 +1,335 @@
+<?php
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+namespace Google\Service\Compute;
+
+class CachePolicy extends \Google\Collection
+{
+  /**
+   * 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.
+   */
+  public const CACHE_MODE_CACHE_ALL_STATIC = 'CACHE_ALL_STATIC';
+  /**
+   * 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.
+   */
+  public const CACHE_MODE_FORCE_CACHE_ALL = 'FORCE_CACHE_ALL';
+  /**
+   * Requires the origin to set valid caching headers to cache content.
+   * Responses without these headers will not be cached at the edge, and will
+   * require a full trip to the origin on every request, potentially impacting
+   * performance and increasing load on the origin server.
+   */
+  public const CACHE_MODE_USE_ORIGIN_HEADERS = 'USE_ORIGIN_HEADERS';
+  protected $collection_key = 'negativeCachingPolicy';
+  /**
+   * Bypass the cache when the specified request headers are matched by name,
+   * e.g. Pragma or Authorization headers. Values are case-insensitive. Up to 5
+   * header names can be specified. The cache is bypassed for all `cacheMode`
+   * values.
+   *
+   * @var string[]
+   */
+  public $cacheBypassRequestHeaderNames;
+  protected $cacheKeyPolicyType = CachePolicyCacheKeyPolicy::class;
+  protected $cacheKeyPolicyDataType = '';
+  /**
+   * Specifies the cache setting for all responses from this route. If not
+   * specified, Cloud CDN uses `CACHE_ALL_STATIC` mode.
+   *
+   * @var string
+   */
+  public $cacheMode;
+  protected $clientTtlType = Duration::class;
+  protected $clientTtlDataType = '';
+  protected $defaultTtlType = Duration::class;
+  protected $defaultTtlDataType = '';
+  protected $maxTtlType = Duration::class;
+  protected $maxTtlDataType = '';
+  /**
+   * Negative caching allows per-status code TTLs to be set, in order to apply
+   * fine-grained caching for common errors or redirects. This can reduce the
+   * load on your origin and improve end-user experience by reducing response
+   * latency. When the `cacheMode` is set to `CACHE_ALL_STATIC` or
+   * `USE_ORIGIN_HEADERS`, negative caching applies to responses with the
+   * specified response code that lack any Cache-Control, Expires, or Pragma:
+   * no-cache directives. When the `cacheMode` is set to `FORCE_CACHE_ALL`,
+   * negative caching applies to all responses with the specified response code,
+   * and overrides any caching headers. By default, Cloud CDN applies the
+   * following TTLs to these HTTP status codes:
+   *
+   * * 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m * 404 (Not
+   * Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s * 405 (Method
+   * Not Found), 501 (Not Implemented): 60s
+   *
+   * These defaults can be overridden in `negativeCachingPolicy`. If not
+   * specified, Cloud CDN applies negative caching by default.
+   *
+   * @var bool
+   */
+  public $negativeCaching;
+  protected $negativeCachingPolicyType = CachePolicyNegativeCachingPolicy::class;
+  protected $negativeCachingPolicyDataType = 'array';
+  /**
+   * If true then Cloud CDN will combine multiple concurrent cache fill requests
+   * into a small number of requests to the origin. If not specified, Cloud CDN
+   * applies request coalescing by default.
+   *
+   * @var bool
+   */
+  public $requestCoalescing;
+  protected $serveWhileStaleType = Duration::class;
+  protected $serveWhileStaleDataType = '';
+
+  /**
+   * Bypass the cache when the specified request headers are matched by name,
+   * e.g. Pragma or Authorization headers. Values are case-insensitive. Up to 5
+   * header names can be specified. The cache is bypassed for all `cacheMode`
+   * values.
+   *
+   * @param string[] $cacheBypassRequestHeaderNames
+   */
+  public function setCacheBypassRequestHeaderNames($cacheBypassRequestHeaderNames)
+  {
+    $this->cacheBypassRequestHeaderNames = $cacheBypassRequestHeaderNames;
+  }
+  /**
+   * @return string[]
+   */
+  public function getCacheBypassRequestHeaderNames()
+  {
+    return $this->cacheBypassRequestHeaderNames;
+  }
+  /**
+   * The cache key configuration. If not specified, the default behavior depends
+   * on the backend type: for Backend Services, the complete request URI is
+   * used; for Backend Buckets, the request URI is used without the protocol or
+   * host, and only query parameters known to Cloud Storage are included.
+   *
+   * @param CachePolicyCacheKeyPolicy $cacheKeyPolicy
+   */
+  public function setCacheKeyPolicy(CachePolicyCacheKeyPolicy $cacheKeyPolicy)
+  {
+    $this->cacheKeyPolicy = $cacheKeyPolicy;
+  }
+  /**
+   * @return CachePolicyCacheKeyPolicy
+   */
+  public function getCacheKeyPolicy()
+  {
+    return $this->cacheKeyPolicy;
+  }
+  /**
+   * Specifies the cache setting for all responses from this route. If not
+   * specified, Cloud CDN uses `CACHE_ALL_STATIC` mode.
+   *
+   * Accepted values: CACHE_ALL_STATIC, FORCE_CACHE_ALL, USE_ORIGIN_HEADERS
+   *
+   * @param self::CACHE_MODE_* $cacheMode
+   */
+  public function setCacheMode($cacheMode)
+  {
+    $this->cacheMode = $cacheMode;
+  }
+  /**
+   * @return self::CACHE_MODE_*
+   */
+  public function getCacheMode()
+  {
+    return $this->cacheMode;
+  }
+  /**
+   * Specifies a separate client (e.g. browser client) maximum TTL for cached
+   * content. This is used to clamp the max-age (or Expires) value sent to the
+   * client. With `FORCE_CACHE_ALL`, the lesser of `clientTtl` and `defaultTtl`
+   * is used for the response max-age directive, along with a "public"
+   * directive. For cacheable content in `CACHE_ALL_STATIC` mode, `clientTtl`
+   * clamps the max-age from the origin (if specified), or else sets the
+   * response max-age directive to the lesser of the `clientTtl` and
+   * `defaultTtl`, and also ensures a "public" cache-control directive is
+   * present. The maximum allowed value is 31,622,400s (1 year). If not
+   * specified, Cloud CDN uses 3600s (1 hour) for `CACHE_ALL_STATIC` mode.
+   * Cannot exceed `maxTtl`. Cannot be specified when `cacheMode` is
+   * `USE_ORIGIN_HEADERS`.
+   *
+   * @param Duration $clientTtl
+   */
+  public function setClientTtl(Duration $clientTtl)
+  {
+    $this->clientTtl = $clientTtl;
+  }
+  /**
+   * @return Duration
+   */
+  public function getClientTtl()
+  {
+    return $this->clientTtl;
+  }
+  /**
+   * Specifies the default TTL for cached content for responses that do not have
+   * an existing valid TTL (max-age or s-maxage). Setting a TTL of "0" means
+   * "always revalidate". The value of `defaultTtl` cannot be set to a value
+   * greater than that of `maxTtl`. 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). Infrequently
+   * accessed objects may be evicted from the cache before the defined TTL. If
+   * not specified, Cloud CDN uses 3600s (1 hour) for `CACHE_ALL_STATIC` and
+   * `FORCE_CACHE_ALL` modes. Cannot be specified when `cacheMode` is
+   * `USE_ORIGIN_HEADERS`.
+   *
+   * @param Duration $defaultTtl
+   */
+  public function setDefaultTtl(Duration $defaultTtl)
+  {
+    $this->defaultTtl = $defaultTtl;
+  }
+  /**
+   * @return Duration
+   */
+  public function getDefaultTtl()
+  {
+    return $this->defaultTtl;
+  }
+  /**
+   * Specifies the maximum allowed TTL for cached content. 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).
+   * Infrequently accessed objects may be evicted from the cache before the
+   * defined TTL. If not specified, Cloud CDN uses 86400s (1 day) for
+   * `CACHE_ALL_STATIC` mode. Can be specified only for `CACHE_ALL_STATIC` cache
+   * mode.
+   *
+   * @param Duration $maxTtl
+   */
+  public function setMaxTtl(Duration $maxTtl)
+  {
+    $this->maxTtl = $maxTtl;
+  }
+  /**
+   * @return Duration
+   */
+  public function getMaxTtl()
+  {
+    return $this->maxTtl;
+  }
+  /**
+   * Negative caching allows per-status code TTLs to be set, in order to apply
+   * fine-grained caching for common errors or redirects. This can reduce the
+   * load on your origin and improve end-user experience by reducing response
+   * latency. When the `cacheMode` is set to `CACHE_ALL_STATIC` or
+   * `USE_ORIGIN_HEADERS`, negative caching applies to responses with the
+   * specified response code that lack any Cache-Control, Expires, or Pragma:
+   * no-cache directives. When the `cacheMode` is set to `FORCE_CACHE_ALL`,
+   * negative caching applies to all responses with the specified response code,
+   * and overrides any caching headers. By default, Cloud CDN applies the
+   * following TTLs to these HTTP status codes:
+   *
+   * * 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m * 404 (Not
+   * Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s * 405 (Method
+   * Not Found), 501 (Not Implemented): 60s
+   *
+   * These defaults can be overridden in `negativeCachingPolicy`. If not
+   * specified, Cloud CDN applies negative caching by default.
+   *
+   * @param bool $negativeCaching
+   */
+  public function setNegativeCaching($negativeCaching)
+  {
+    $this->negativeCaching = $negativeCaching;
+  }
+  /**
+   * @return bool
+   */
+  public function getNegativeCaching()
+  {
+    return $this->negativeCaching;
+  }
+  /**
+   * Sets a cache TTL for the specified HTTP status code. `negativeCaching` must
+   * be enabled to configure `negativeCachingPolicy`. Omitting the policy and
+   * leaving `negativeCaching` enabled will use Cloud CDN's default cache TTLs.
+   * Note that when specifying an explicit `negativeCachingPolicy`, you should
+   * take care to specify a cache TTL for all response codes that you wish to
+   * cache. Cloud CDN will not apply any default negative caching when a policy
+   * exists.
+   *
+   * @param CachePolicyNegativeCachingPolicy[] $negativeCachingPolicy
+   */
+  public function setNegativeCachingPolicy($negativeCachingPolicy)
+  {
+    $this->negativeCachingPolicy = $negativeCachingPolicy;
+  }
+  /**
+   * @return CachePolicyNegativeCachingPolicy[]
+   */
+  public function getNegativeCachingPolicy()
+  {
+    return $this->negativeCachingPolicy;
+  }
+  /**
+   * If true then Cloud CDN will combine multiple concurrent cache fill requests
+   * into a small number of requests to the origin. If not specified, Cloud CDN
+   * applies request coalescing by default.
+   *
+   * @param bool $requestCoalescing
+   */
+  public function setRequestCoalescing($requestCoalescing)
+  {
+    $this->requestCoalescing = $requestCoalescing;
+  }
+  /**
+   * @return bool
+   */
+  public function getRequestCoalescing()
+  {
+    return $this->requestCoalescing;
+  }
+  /**
+   * Serve existing content from the cache (if available) when revalidating
+   * content with the origin, or when an error is encountered when refreshing
+   * the cache. This setting defines the default "max-stale" duration for any
+   * cached responses that do not specify a max-stale directive. Stale responses
+   * that exceed the TTL configured here will not be served. The default limit
+   * (max-stale) is 86400s (1 day), which will allow stale content to be served
+   * up to this limit beyond the max-age (or s-maxage) of a cached response. The
+   * maximum allowed value is 604800 (1 week). Set this to zero (0) to disable
+   * serve-while-stale.
+   *
+   * @param Duration $serveWhileStale
+   */
+  public function setServeWhileStale(Duration $serveWhileStale)
+  {
+    $this->serveWhileStale = $serveWhileStale;
+  }
+  /**
+   * @return Duration
+   */
+  public function getServeWhileStale()
+  {
+    return $this->serveWhileStale;
+  }
+}
+
+// Adding a class alias for backwards compatibility with the previous class name.
+class_alias(CachePolicy::class, 'Google_Service_Compute_CachePolicy');