// Code generated by sidekick. DO NOT EDIT.
//
// Copyright 2026 Google LLC
//
// 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
//
//     https://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.

#if BackendBuckets || RegionBackendBuckets
  import Foundation
  import GoogleCloudWkt

  /// Message containing Cloud CDN configuration for a backend bucket.
  public struct BackendBucketCdnPolicy: Codable, Equatable, GoogleCloudWkt._AnyPackable,
    Sendable
  {
    /// 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.
    public var bypassCacheOnRequestHeaders: [BackendBucketCdnPolicyBypassCacheOnRequestHeader] = []

    /// The CacheKeyPolicy for this CdnPolicy.
    public var cacheKeyPolicy: BackendBucketCdnPolicyCacheKeyPolicy? = 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.
    public var cacheMode: BackendBucketCdnPolicy.CacheMode? = 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).
    public var clientTtl: Swift.Int32? = 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-maxage).
    /// 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.
    public var defaultTtl: Swift.Int32? = 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.
    public var maxTtl: Swift.Int32? = nil

    /// 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 cache mode 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 cache mode is set to FORCE_CACHE_ALL, negative caching applies
    /// to all responses with the specified response code, and override any
    /// caching headers.
    /// By default, Cloud CDN will apply the following default TTLs to these
    /// status codes:
    /// HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m
    /// HTTP 404 (Not Found), 410 (Gone),
    /// 451 (Unavailable For Legal Reasons): 120s
    /// HTTP 405 (Method Not Found), 501 (Not Implemented): 60s.
    /// These defaults can be overridden in negative_caching_policy.
    public var negativeCaching: Swift.Bool? = nil

    /// Sets a cache TTL for the specified HTTP status code.
    /// negative_caching must be enabled to configure negative_caching_policy.
    /// Omitting the policy and leaving negative_caching enabled will use
    /// Cloud CDN's default cache TTLs.
    /// Note that when specifying an explicit negative_caching_policy, 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.
    public var negativeCachingPolicy: [BackendBucketCdnPolicyNegativeCachingPolicy] = []

    /// If true then Cloud CDN will combine multiple concurrent cache fill
    /// requests into a small number of requests to the origin.
    public var requestCoalescing: Swift.Bool? = nil

    /// 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.
    public var serveWhileStale: Swift.Int32? = nil

    /// Maximum number of seconds the response to a signed URL request will be
    /// considered fresh. After this time period, the response will be
    /// revalidated before being served. Defaults to 1hr (3600s).  When serving
    /// responses to signed URL requests, Cloud CDN will internally behave as
    /// though all responses from this backend had a "Cache-Control:
    /// public, max-age=[TTL]" header, regardless of any existing
    /// Cache-Control header. The actual headers served in responses will not be
    /// altered.
    public var signedUrlCacheMaxAgeSec: Swift.Int64? = nil

    /// [Output Only] Names of the keys for signing request URLs.
    public var signedUrlKeyNames: [Swift.String] = []

    /// Initialize a new instance of `BackendBucketCdnPolicy`.
    public init() {}

    /// Use `config` to return a new instance of this object, with some fields updated.
    ///
    /// Commonly used to initialize the value, for example:
    ///
    /// ```
    /// let value = BackendBucketCdnPolicy().with { $0.bypassCacheOnRequestHeaders = ... }
    /// ```
    public func with(_ config: (inout Self) throws -> Swift.Void) rethrows -> Self {
      var copy = self
      try config(&copy)
      return copy
    }

    /// The enumerated type for the [cacheMode][google.cloud.compute.v1.BackendBucketCdnPolicy.cacheMode] field.
    ///
    /// [google.cloud.compute.v1.BackendBucketCdnPolicy.cacheMode]: <doc:BackendBucketCdnPolicy/CacheMode>
    public enum CacheMode: Codable, Equatable, Sendable {
      /// 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.
      case cacheAllStatic
      /// 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.
      case forceCacheAll
      case invalidCacheMode
      /// 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.
      case useOriginHeaders
      /// Encodes an unknown integer value.
      ///
      /// The most common cause for an unknown values is for the service to send
      /// a value unknown to the library. We recommend you update your library to
      /// the latest version.
      case unknownIntValue(Int)
      /// Encodes an unknown string value.
      ///
      /// The most common cause for an unknown values is for the service to send
      /// a value unknown to the library. We recommend you update your library to
      /// the latest version.
      case unknownStringValue(String)

      public init() {
        self = .cacheAllStatic
      }

      /// Returns the integer value associated with the enumeration.
      ///
      /// If the enumeration was initialized with an unknown string value, this returns `nil`.
      public var intValue: Int? {
        switch self {
        case .cacheAllStatic: return 0
        case .forceCacheAll: return 1
        case .invalidCacheMode: return 2
        case .useOriginHeaders: return 3
        case .unknownIntValue(let v): return v
        case .unknownStringValue: return nil
        }
      }

      /// Returns the string value (or name) associated with the enumeration.
      ///
      /// If the enumeration was initialized with an unknown integer value, this returns `nil`.
      public var stringValue: Swift.String? {
        switch self {
        case .cacheAllStatic: return "CACHE_ALL_STATIC"
        case .forceCacheAll: return "FORCE_CACHE_ALL"
        case .invalidCacheMode: return "INVALID_CACHE_MODE"
        case .useOriginHeaders: return "USE_ORIGIN_HEADERS"
        case .unknownIntValue: return nil
        case .unknownStringValue(let v): return v
        }
      }

      /// Initialize from a string value.
      ///
      /// If the value is unknown, this initializes to [`unknownStringValue`](doc:CacheMode/unknownStringValue(_:)).
      public init(stringValue: Swift.String) {
        switch stringValue {
        case "CACHE_ALL_STATIC": self = .cacheAllStatic
        case "FORCE_CACHE_ALL": self = .forceCacheAll
        case "INVALID_CACHE_MODE": self = .invalidCacheMode
        case "USE_ORIGIN_HEADERS": self = .useOriginHeaders
        default: self = .unknownStringValue(stringValue)
        }
      }

      /// Initialize from an integer value.
      ///
      /// If the value is unknown, this initializes to [`unknownIntValue`](doc:CacheMode/unknownIntValue(_:)).
      public init(intValue: Int) {
        switch intValue {
        case 0: self = .cacheAllStatic
        case 1: self = .forceCacheAll
        case 2: self = .invalidCacheMode
        case 3: self = .useOriginHeaders
        default: self = .unknownIntValue(intValue)
        }
      }

      public init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        if let v = try? container.decode(Int.self) {
          self.init(intValue: v)
          return
        }
        if let s = try? container.decode(String.self) {
          if let v = Int(s) {
            self.init(intValue: v)
          } else {
            self.init(stringValue: s)
          }
          return
        }
        throw DecodingError.dataCorruptedError(
          in: container, debugDescription: "Expected enum value, must be integer or string.")
      }

      public func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        switch self {
        case .cacheAllStatic: return try container.encode(0)
        case .forceCacheAll: return try container.encode(1)
        case .invalidCacheMode: return try container.encode(2)
        case .useOriginHeaders: return try container.encode(3)
        case .unknownIntValue(let v): return try container.encode(v)
        case .unknownStringValue(let v): return try container.encode(v)
        }
      }
    }

    public static var _anyTypeUrl: Swift.String {
      return "type.googleapis.com/google.cloud.compute.v1.BackendBucketCdnPolicy"
    }
    public init(fromAny any: GoogleCloudWkt.`Any`) throws {
      self = try GoogleCloudWkt._slowAnyDeserialize(Self.self, from: any)
    }
    public func _pack() throws -> GoogleCloudWkt.Struct {
      return try GoogleCloudWkt._slowAnySerialize(message: self)
    }
  }
#endif
