text: # coding=utf-8
  # *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
  
  import warnings
  import pulumi
  import pulumi.runtime
  from typing import Any, Mapping, Optional, Sequence, Union, overload
  from .. import _utilities
  from . import outputs
  
  __all__ = [
      'CachePolicyParametersInCacheKeyAndForwardedToOrigin',
      'CachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfig',
      'CachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigCookies',
      'CachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfig',
      'CachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigHeaders',
      'CachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfig',
      'CachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigQueryStrings',
      'DistributionCustomErrorResponse',
      'DistributionDefaultCacheBehavior',
      'DistributionDefaultCacheBehaviorForwardedValues',
      'DistributionDefaultCacheBehaviorForwardedValuesCookies',
      'DistributionDefaultCacheBehaviorFunctionAssociation',
      'DistributionDefaultCacheBehaviorLambdaFunctionAssociation',
      'DistributionLoggingConfig',
      'DistributionOrderedCacheBehavior',
      'DistributionOrderedCacheBehaviorForwardedValues',
      'DistributionOrderedCacheBehaviorForwardedValuesCookies',
      'DistributionOrderedCacheBehaviorFunctionAssociation',
      'DistributionOrderedCacheBehaviorLambdaFunctionAssociation',
      'DistributionOrigin',
      'DistributionOriginCustomHeader',
      'DistributionOriginCustomOriginConfig',
      'DistributionOriginGroup',
      'DistributionOriginGroupFailoverCriteria',
      'DistributionOriginGroupMember',
      'DistributionOriginOriginShield',
      'DistributionOriginS3OriginConfig',
      'DistributionRestrictions',
      'DistributionRestrictionsGeoRestriction',
      'DistributionTrustedKeyGroup',
      'DistributionTrustedKeyGroupItem',
      'DistributionTrustedSigner',
      'DistributionTrustedSignerItem',
      'DistributionViewerCertificate',
      'MonitoringSubscriptionMonitoringSubscription',
      'MonitoringSubscriptionMonitoringSubscriptionRealtimeMetricsSubscriptionConfig',
      'OriginRequestPolicyCookiesConfig',
      'OriginRequestPolicyCookiesConfigCookies',
      'OriginRequestPolicyHeadersConfig',
      'OriginRequestPolicyHeadersConfigHeaders',
      'OriginRequestPolicyQueryStringsConfig',
      'OriginRequestPolicyQueryStringsConfigQueryStrings',
      'RealtimeLogConfigEndpoint',
      'RealtimeLogConfigEndpointKinesisStreamConfig',
      'ResponseHeadersPolicyCorsConfig',
      'ResponseHeadersPolicyCorsConfigAccessControlAllowHeaders',
      'ResponseHeadersPolicyCorsConfigAccessControlAllowMethods',
      'ResponseHeadersPolicyCorsConfigAccessControlAllowOrigins',
      'ResponseHeadersPolicyCorsConfigAccessControlExposeHeaders',
      'ResponseHeadersPolicyCustomHeadersConfig',
      'ResponseHeadersPolicyCustomHeadersConfigItem',
      'ResponseHeadersPolicySecurityHeadersConfig',
      'ResponseHeadersPolicySecurityHeadersConfigContentSecurityPolicy',
      'ResponseHeadersPolicySecurityHeadersConfigContentTypeOptions',
      'ResponseHeadersPolicySecurityHeadersConfigFrameOptions',
      'ResponseHeadersPolicySecurityHeadersConfigReferrerPolicy',
      'ResponseHeadersPolicySecurityHeadersConfigStrictTransportSecurity',
      'ResponseHeadersPolicySecurityHeadersConfigXssProtection',
      'GetCachePolicyParametersInCacheKeyAndForwardedToOriginResult',
      'GetCachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigResult',
      'GetCachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigCookieResult',
      'GetCachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigResult',
      'GetCachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigHeaderResult',
      'GetCachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigResult',
      'GetCachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigQueryStringResult',
      'GetOriginRequestPolicyCookiesConfigResult',
      'GetOriginRequestPolicyCookiesConfigCookieResult',
      'GetOriginRequestPolicyHeadersConfigResult',
      'GetOriginRequestPolicyHeadersConfigHeaderResult',
      'GetOriginRequestPolicyQueryStringsConfigResult',
      'GetOriginRequestPolicyQueryStringsConfigQueryStringResult',
      'GetResponseHeadersPolicyCorsConfigResult',
      'GetResponseHeadersPolicyCorsConfigAccessControlAllowHeaderResult',
      'GetResponseHeadersPolicyCorsConfigAccessControlAllowMethodResult',
      'GetResponseHeadersPolicyCorsConfigAccessControlAllowOriginResult',
      'GetResponseHeadersPolicyCorsConfigAccessControlExposeHeaderResult',
      'GetResponseHeadersPolicyCustomHeadersConfigResult',
      'GetResponseHeadersPolicySecurityHeadersConfigResult',
      'GetResponseHeadersPolicySecurityHeadersConfigContentSecurityPolicyResult',
      'GetResponseHeadersPolicySecurityHeadersConfigContentTypeOptionResult',
      'GetResponseHeadersPolicySecurityHeadersConfigFrameOptionResult',
      'GetResponseHeadersPolicySecurityHeadersConfigReferrerPolicyResult',
      'GetResponseHeadersPolicySecurityHeadersConfigStrictTransportSecurityResult',
      'GetResponseHeadersPolicySecurityHeadersConfigXssProtectionResult',
  ]
  
  @pulumi.output_type
  class CachePolicyParametersInCacheKeyAndForwardedToOrigin(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "cookiesConfig":
              suggest = "cookies_config"
          elif key == "headersConfig":
              suggest = "headers_config"
          elif key == "queryStringsConfig":
              suggest = "query_strings_config"
          elif key == "enableAcceptEncodingBrotli":
              suggest = "enable_accept_encoding_brotli"
          elif key == "enableAcceptEncodingGzip":
              suggest = "enable_accept_encoding_gzip"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in CachePolicyParametersInCacheKeyAndForwardedToOrigin. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          CachePolicyParametersInCacheKeyAndForwardedToOrigin.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          CachePolicyParametersInCacheKeyAndForwardedToOrigin.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   cookies_config: 'outputs.CachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfig',
                   headers_config: 'outputs.CachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfig',
                   query_strings_config: 'outputs.CachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfig',
                   enable_accept_encoding_brotli: Optional[bool] = None,
                   enable_accept_encoding_gzip: Optional[bool] = None):
          """
          :param 'CachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigArgs' cookies_config: Object that determines whether any cookies in viewer requests (and if so, which cookies) are included in the cache key and automatically included in requests that CloudFront sends to the origin. See Cookies Config for more information.
          :param 'CachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigArgs' headers_config: Object that determines whether any HTTP headers (and if so, which headers) are included in the cache key and automatically included in requests that CloudFront sends to the origin. See Headers Config for more information.
          :param 'CachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigArgs' query_strings_config: Object that determines whether any URL query strings in viewer requests (and if so, which query strings) are included in the cache key and automatically included in requests that CloudFront sends to the origin. See Query Strings Config for more information.
          :param bool enable_accept_encoding_brotli: A flag that can affect whether the Accept-Encoding HTTP header is included in the cache key and included in requests that CloudFront sends to the origin.
          :param bool enable_accept_encoding_gzip: A flag that can affect whether the Accept-Encoding HTTP header is included in the cache key and included in requests that CloudFront sends to the origin.
          """
          pulumi.set(__self__, "cookies_config", cookies_config)
          pulumi.set(__self__, "headers_config", headers_config)
          pulumi.set(__self__, "query_strings_config", query_strings_config)
          if enable_accept_encoding_brotli is not None:
              pulumi.set(__self__, "enable_accept_encoding_brotli", enable_accept_encoding_brotli)
          if enable_accept_encoding_gzip is not None:
              pulumi.set(__self__, "enable_accept_encoding_gzip", enable_accept_encoding_gzip)
  
      @property
      @pulumi.getter(name="cookiesConfig")
      def cookies_config(self) -> 'outputs.CachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfig':
          """
          Object that determines whether any cookies in viewer requests (and if so, which cookies) are included in the cache key and automatically included in requests that CloudFront sends to the origin. See Cookies Config for more information.
          """
          return pulumi.get(self, "cookies_config")
  
      @property
      @pulumi.getter(name="headersConfig")
      def headers_config(self) -> 'outputs.CachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfig':
          """
          Object that determines whether any HTTP headers (and if so, which headers) are included in the cache key and automatically included in requests that CloudFront sends to the origin. See Headers Config for more information.
          """
          return pulumi.get(self, "headers_config")
  
      @property
      @pulumi.getter(name="queryStringsConfig")
      def query_strings_config(self) -> 'outputs.CachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfig':
          """
          Object that determines whether any URL query strings in viewer requests (and if so, which query strings) are included in the cache key and automatically included in requests that CloudFront sends to the origin. See Query Strings Config for more information.
          """
          return pulumi.get(self, "query_strings_config")
  
      @property
      @pulumi.getter(name="enableAcceptEncodingBrotli")
      def enable_accept_encoding_brotli(self) -> Optional[bool]:
          """
          A flag that can affect whether the Accept-Encoding HTTP header is included in the cache key and included in requests that CloudFront sends to the origin.
          """
          return pulumi.get(self, "enable_accept_encoding_brotli")
  
      @property
      @pulumi.getter(name="enableAcceptEncodingGzip")
      def enable_accept_encoding_gzip(self) -> Optional[bool]:
          """
          A flag that can affect whether the Accept-Encoding HTTP header is included in the cache key and included in requests that CloudFront sends to the origin.
          """
          return pulumi.get(self, "enable_accept_encoding_gzip")
  
  
  @pulumi.output_type
  class CachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfig(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "cookieBehavior":
              suggest = "cookie_behavior"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in CachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfig. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          CachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfig.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          CachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfig.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   cookie_behavior: str,
                   cookies: Optional['outputs.CachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigCookies'] = None):
          """
          :param str cookie_behavior: Determines whether any cookies in viewer requests are included in the cache key and automatically included in requests that CloudFront sends to the origin. Valid values are `none`, `whitelist`, `allExcept`, `all`.
          :param 'CachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigCookiesArgs' cookies: Object that contains a list of cookie names. See Items for more information.
          """
          pulumi.set(__self__, "cookie_behavior", cookie_behavior)
          if cookies is not None:
              pulumi.set(__self__, "cookies", cookies)
  
      @property
      @pulumi.getter(name="cookieBehavior")
      def cookie_behavior(self) -> str:
          """
          Determines whether any cookies in viewer requests are included in the cache key and automatically included in requests that CloudFront sends to the origin. Valid values are `none`, `whitelist`, `allExcept`, `all`.
          """
          return pulumi.get(self, "cookie_behavior")
  
      @property
      @pulumi.getter
      def cookies(self) -> Optional['outputs.CachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigCookies']:
          """
          Object that contains a list of cookie names. See Items for more information.
          """
          return pulumi.get(self, "cookies")
  
  
  @pulumi.output_type
  class CachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigCookies(dict):
      def __init__(__self__, *,
                   items: Optional[Sequence[str]] = None):
          """
          :param Sequence[str] items: A list of item names (cookies, headers, or query strings).
          """
          if items is not None:
              pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Optional[Sequence[str]]:
          """
          A list of item names (cookies, headers, or query strings).
          """
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class CachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfig(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "headerBehavior":
              suggest = "header_behavior"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in CachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfig. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          CachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfig.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          CachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfig.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   header_behavior: Optional[str] = None,
                   headers: Optional['outputs.CachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigHeaders'] = None):
          """
          :param str header_behavior: Determines whether any HTTP headers are included in the cache key and automatically included in requests that CloudFront sends to the origin. Valid values are `none`, `whitelist`.
          :param 'CachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigHeadersArgs' headers: Object that contains a list of header names. See Items for more information.
          """
          if header_behavior is not None:
              pulumi.set(__self__, "header_behavior", header_behavior)
          if headers is not None:
              pulumi.set(__self__, "headers", headers)
  
      @property
      @pulumi.getter(name="headerBehavior")
      def header_behavior(self) -> Optional[str]:
          """
          Determines whether any HTTP headers are included in the cache key and automatically included in requests that CloudFront sends to the origin. Valid values are `none`, `whitelist`.
          """
          return pulumi.get(self, "header_behavior")
  
      @property
      @pulumi.getter
      def headers(self) -> Optional['outputs.CachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigHeaders']:
          """
          Object that contains a list of header names. See Items for more information.
          """
          return pulumi.get(self, "headers")
  
  
  @pulumi.output_type
  class CachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigHeaders(dict):
      def __init__(__self__, *,
                   items: Optional[Sequence[str]] = None):
          """
          :param Sequence[str] items: A list of item names (cookies, headers, or query strings).
          """
          if items is not None:
              pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Optional[Sequence[str]]:
          """
          A list of item names (cookies, headers, or query strings).
          """
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class CachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfig(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "queryStringBehavior":
              suggest = "query_string_behavior"
          elif key == "queryStrings":
              suggest = "query_strings"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in CachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfig. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          CachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfig.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          CachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfig.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   query_string_behavior: str,
                   query_strings: Optional['outputs.CachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigQueryStrings'] = None):
          """
          :param str query_string_behavior: Determines whether any URL query strings in viewer requests are included in the cache key and automatically included in requests that CloudFront sends to the origin. Valid values are `none`, `whitelist`, `allExcept`, `all`.
          :param 'CachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigQueryStringsArgs' query_strings: Object that contains a list of query string names. See Items for more information.
          """
          pulumi.set(__self__, "query_string_behavior", query_string_behavior)
          if query_strings is not None:
              pulumi.set(__self__, "query_strings", query_strings)
  
      @property
      @pulumi.getter(name="queryStringBehavior")
      def query_string_behavior(self) -> str:
          """
          Determines whether any URL query strings in viewer requests are included in the cache key and automatically included in requests that CloudFront sends to the origin. Valid values are `none`, `whitelist`, `allExcept`, `all`.
          """
          return pulumi.get(self, "query_string_behavior")
  
      @property
      @pulumi.getter(name="queryStrings")
      def query_strings(self) -> Optional['outputs.CachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigQueryStrings']:
          """
          Object that contains a list of query string names. See Items for more information.
          """
          return pulumi.get(self, "query_strings")
  
  
  @pulumi.output_type
  class CachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigQueryStrings(dict):
      def __init__(__self__, *,
                   items: Optional[Sequence[str]] = None):
          """
          :param Sequence[str] items: A list of item names (cookies, headers, or query strings).
          """
          if items is not None:
              pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Optional[Sequence[str]]:
          """
          A list of item names (cookies, headers, or query strings).
          """
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class DistributionCustomErrorResponse(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "errorCode":
              suggest = "error_code"
          elif key == "errorCachingMinTtl":
              suggest = "error_caching_min_ttl"
          elif key == "responseCode":
              suggest = "response_code"
          elif key == "responsePagePath":
              suggest = "response_page_path"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionCustomErrorResponse. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionCustomErrorResponse.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionCustomErrorResponse.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   error_code: int,
                   error_caching_min_ttl: Optional[int] = None,
                   response_code: Optional[int] = None,
                   response_page_path: Optional[str] = None):
          """
          :param int error_code: The 4xx or 5xx HTTP status code that you want to
                 customize.
          :param int error_caching_min_ttl: The minimum amount of time you want
                 HTTP error codes to stay in CloudFront caches before CloudFront queries your
                 origin to see whether the object has been updated.
          :param int response_code: The HTTP status code that you want CloudFront
                 to return with the custom error page to the viewer.
          :param str response_page_path: The path of the custom error page (for
                 example, `/custom_404.html`).
          """
          pulumi.set(__self__, "error_code", error_code)
          if error_caching_min_ttl is not None:
              pulumi.set(__self__, "error_caching_min_ttl", error_caching_min_ttl)
          if response_code is not None:
              pulumi.set(__self__, "response_code", response_code)
          if response_page_path is not None:
              pulumi.set(__self__, "response_page_path", response_page_path)
  
      @property
      @pulumi.getter(name="errorCode")
      def error_code(self) -> int:
          """
          The 4xx or 5xx HTTP status code that you want to
          customize.
          """
          return pulumi.get(self, "error_code")
  
      @property
      @pulumi.getter(name="errorCachingMinTtl")
      def error_caching_min_ttl(self) -> Optional[int]:
          """
          The minimum amount of time you want
          HTTP error codes to stay in CloudFront caches before CloudFront queries your
          origin to see whether the object has been updated.
          """
          return pulumi.get(self, "error_caching_min_ttl")
  
      @property
      @pulumi.getter(name="responseCode")
      def response_code(self) -> Optional[int]:
          """
          The HTTP status code that you want CloudFront
          to return with the custom error page to the viewer.
          """
          return pulumi.get(self, "response_code")
  
      @property
      @pulumi.getter(name="responsePagePath")
      def response_page_path(self) -> Optional[str]:
          """
          The path of the custom error page (for
          example, `/custom_404.html`).
          """
          return pulumi.get(self, "response_page_path")
  
  
  @pulumi.output_type
  class DistributionDefaultCacheBehavior(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "allowedMethods":
              suggest = "allowed_methods"
          elif key == "cachedMethods":
              suggest = "cached_methods"
          elif key == "targetOriginId":
              suggest = "target_origin_id"
          elif key == "viewerProtocolPolicy":
              suggest = "viewer_protocol_policy"
          elif key == "cachePolicyId":
              suggest = "cache_policy_id"
          elif key == "defaultTtl":
              suggest = "default_ttl"
          elif key == "fieldLevelEncryptionId":
              suggest = "field_level_encryption_id"
          elif key == "forwardedValues":
              suggest = "forwarded_values"
          elif key == "functionAssociations":
              suggest = "function_associations"
          elif key == "lambdaFunctionAssociations":
              suggest = "lambda_function_associations"
          elif key == "maxTtl":
              suggest = "max_ttl"
          elif key == "minTtl":
              suggest = "min_ttl"
          elif key == "originRequestPolicyId":
              suggest = "origin_request_policy_id"
          elif key == "realtimeLogConfigArn":
              suggest = "realtime_log_config_arn"
          elif key == "responseHeadersPolicyId":
              suggest = "response_headers_policy_id"
          elif key == "smoothStreaming":
              suggest = "smooth_streaming"
          elif key == "trustedKeyGroups":
              suggest = "trusted_key_groups"
          elif key == "trustedSigners":
              suggest = "trusted_signers"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionDefaultCacheBehavior. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionDefaultCacheBehavior.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionDefaultCacheBehavior.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   allowed_methods: Sequence[str],
                   cached_methods: Sequence[str],
                   target_origin_id: str,
                   viewer_protocol_policy: str,
                   cache_policy_id: Optional[str] = None,
                   compress: Optional[bool] = None,
                   default_ttl: Optional[int] = None,
                   field_level_encryption_id: Optional[str] = None,
                   forwarded_values: Optional['outputs.DistributionDefaultCacheBehaviorForwardedValues'] = None,
                   function_associations: Optional[Sequence['outputs.DistributionDefaultCacheBehaviorFunctionAssociation']] = None,
                   lambda_function_associations: Optional[Sequence['outputs.DistributionDefaultCacheBehaviorLambdaFunctionAssociation']] = None,
                   max_ttl: Optional[int] = None,
                   min_ttl: Optional[int] = None,
                   origin_request_policy_id: Optional[str] = None,
                   realtime_log_config_arn: Optional[str] = None,
                   response_headers_policy_id: Optional[str] = None,
                   smooth_streaming: Optional[bool] = None,
                   trusted_key_groups: Optional[Sequence[str]] = None,
                   trusted_signers: Optional[Sequence[str]] = None):
          """
          :param Sequence[str] allowed_methods: Controls which HTTP methods CloudFront
                 processes and forwards to your Amazon S3 bucket or your custom origin.
          :param Sequence[str] cached_methods: Controls whether CloudFront caches the
                 response to requests using the specified HTTP methods.
          :param str target_origin_id: The value of ID for the origin that you want
                 CloudFront to route requests to when a request matches the path pattern
                 either for a cache behavior or for the default cache behavior.
          :param str viewer_protocol_policy: Use this element to specify the
                 protocol that users can use to access the files in the origin specified by
                 TargetOriginId when a request matches the path pattern in PathPattern. One
                 of `allow-all`, `https-only`, or `redirect-to-https`.
          :param str cache_policy_id: The unique identifier of the cache policy that
                 is attached to the cache behavior.
          :param bool compress: Whether you want CloudFront to automatically
                 compress content for web requests that include `Accept-Encoding: gzip` in
                 the request header (default: `false`).
          :param int default_ttl: The default amount of time (in seconds) that an
                 object is in a CloudFront cache before CloudFront forwards another request
                 in the absence of an `Cache-Control max-age` or `Expires` header.
          :param str field_level_encryption_id: Field level encryption configuration ID
          :param 'DistributionDefaultCacheBehaviorForwardedValuesArgs' forwarded_values: The forwarded values configuration that specifies how CloudFront
                 handles query strings, cookies and headers (maximum one).
          :param Sequence['DistributionDefaultCacheBehaviorFunctionAssociationArgs'] function_associations: A config block that triggers a cloudfront
                 function with specific actions (maximum 2).
          :param Sequence['DistributionDefaultCacheBehaviorLambdaFunctionAssociationArgs'] lambda_function_associations: A config block that triggers a lambda
                 function with specific actions (maximum 4).
          :param int max_ttl: The maximum amount of time (in seconds) that an
                 object is in a CloudFront cache before CloudFront forwards another request
                 to your origin to determine whether the object has been updated. Only
                 effective in the presence of `Cache-Control max-age`, `Cache-Control
                 s-maxage`, and `Expires` headers.
          :param int min_ttl: The minimum amount of time that you want objects to
                 stay in CloudFront caches before CloudFront queries your origin to see
                 whether the object has been updated. Defaults to 0 seconds.
          :param str origin_request_policy_id: The unique identifier of the origin request policy
                 that is attached to the behavior.
          :param str realtime_log_config_arn: The ARN of the real-time log configuration
                 that is attached to this cache behavior.
          :param str response_headers_policy_id: The identifier for a response headers policy.
          :param bool smooth_streaming: Indicates whether you want to distribute
                 media files in Microsoft Smooth Streaming format using the origin that is
                 associated with this cache behavior.
          :param Sequence[str] trusted_key_groups: A list of key group IDs that CloudFront can use to validate signed URLs or signed cookies.
                 See the [CloudFront User Guide](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-trusted-signers.html) for more information about this feature.
          :param Sequence[str] trusted_signers: List of AWS account IDs (or `self`) that you want to allow to create signed URLs for private content.
                 See the [CloudFront User Guide](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-trusted-signers.html) for more information about this feature.
          """
          pulumi.set(__self__, "allowed_methods", allowed_methods)
          pulumi.set(__self__, "cached_methods", cached_methods)
          pulumi.set(__self__, "target_origin_id", target_origin_id)
          pulumi.set(__self__, "viewer_protocol_policy", viewer_protocol_policy)
          if cache_policy_id is not None:
              pulumi.set(__self__, "cache_policy_id", cache_policy_id)
          if compress is not None:
              pulumi.set(__self__, "compress", compress)
          if default_ttl is not None:
              pulumi.set(__self__, "default_ttl", default_ttl)
          if field_level_encryption_id is not None:
              pulumi.set(__self__, "field_level_encryption_id", field_level_encryption_id)
          if forwarded_values is not None:
              pulumi.set(__self__, "forwarded_values", forwarded_values)
          if function_associations is not None:
              pulumi.set(__self__, "function_associations", function_associations)
          if lambda_function_associations is not None:
              pulumi.set(__self__, "lambda_function_associations", lambda_function_associations)
          if max_ttl is not None:
              pulumi.set(__self__, "max_ttl", max_ttl)
          if min_ttl is not None:
              pulumi.set(__self__, "min_ttl", min_ttl)
          if origin_request_policy_id is not None:
              pulumi.set(__self__, "origin_request_policy_id", origin_request_policy_id)
          if realtime_log_config_arn is not None:
              pulumi.set(__self__, "realtime_log_config_arn", realtime_log_config_arn)
          if response_headers_policy_id is not None:
              pulumi.set(__self__, "response_headers_policy_id", response_headers_policy_id)
          if smooth_streaming is not None:
              pulumi.set(__self__, "smooth_streaming", smooth_streaming)
          if trusted_key_groups is not None:
              pulumi.set(__self__, "trusted_key_groups", trusted_key_groups)
          if trusted_signers is not None:
              pulumi.set(__self__, "trusted_signers", trusted_signers)
  
      @property
      @pulumi.getter(name="allowedMethods")
      def allowed_methods(self) -> Sequence[str]:
          """
          Controls which HTTP methods CloudFront
          processes and forwards to your Amazon S3 bucket or your custom origin.
          """
          return pulumi.get(self, "allowed_methods")
  
      @property
      @pulumi.getter(name="cachedMethods")
      def cached_methods(self) -> Sequence[str]:
          """
          Controls whether CloudFront caches the
          response to requests using the specified HTTP methods.
          """
          return pulumi.get(self, "cached_methods")
  
      @property
      @pulumi.getter(name="targetOriginId")
      def target_origin_id(self) -> str:
          """
          The value of ID for the origin that you want
          CloudFront to route requests to when a request matches the path pattern
          either for a cache behavior or for the default cache behavior.
          """
          return pulumi.get(self, "target_origin_id")
  
      @property
      @pulumi.getter(name="viewerProtocolPolicy")
      def viewer_protocol_policy(self) -> str:
          """
          Use this element to specify the
          protocol that users can use to access the files in the origin specified by
          TargetOriginId when a request matches the path pattern in PathPattern. One
          of `allow-all`, `https-only`, or `redirect-to-https`.
          """
          return pulumi.get(self, "viewer_protocol_policy")
  
      @property
      @pulumi.getter(name="cachePolicyId")
      def cache_policy_id(self) -> Optional[str]:
          """
          The unique identifier of the cache policy that
          is attached to the cache behavior.
          """
          return pulumi.get(self, "cache_policy_id")
  
      @property
      @pulumi.getter
      def compress(self) -> Optional[bool]:
          """
          Whether you want CloudFront to automatically
          compress content for web requests that include `Accept-Encoding: gzip` in
          the request header (default: `false`).
          """
          return pulumi.get(self, "compress")
  
      @property
      @pulumi.getter(name="defaultTtl")
      def default_ttl(self) -> Optional[int]:
          """
          The default amount of time (in seconds) that an
          object is in a CloudFront cache before CloudFront forwards another request
          in the absence of an `Cache-Control max-age` or `Expires` header.
          """
          return pulumi.get(self, "default_ttl")
  
      @property
      @pulumi.getter(name="fieldLevelEncryptionId")
      def field_level_encryption_id(self) -> Optional[str]:
          """
          Field level encryption configuration ID
          """
          return pulumi.get(self, "field_level_encryption_id")
  
      @property
      @pulumi.getter(name="forwardedValues")
      def forwarded_values(self) -> Optional['outputs.DistributionDefaultCacheBehaviorForwardedValues']:
          """
          The forwarded values configuration that specifies how CloudFront
          handles query strings, cookies and headers (maximum one).
          """
          return pulumi.get(self, "forwarded_values")
  
      @property
      @pulumi.getter(name="functionAssociations")
      def function_associations(self) -> Optional[Sequence['outputs.DistributionDefaultCacheBehaviorFunctionAssociation']]:
          """
          A config block that triggers a cloudfront
          function with specific actions (maximum 2).
          """
          return pulumi.get(self, "function_associations")
  
      @property
      @pulumi.getter(name="lambdaFunctionAssociations")
      def lambda_function_associations(self) -> Optional[Sequence['outputs.DistributionDefaultCacheBehaviorLambdaFunctionAssociation']]:
          """
          A config block that triggers a lambda
          function with specific actions (maximum 4).
          """
          return pulumi.get(self, "lambda_function_associations")
  
      @property
      @pulumi.getter(name="maxTtl")
      def max_ttl(self) -> Optional[int]:
          """
          The maximum amount of time (in seconds) that an
          object is in a CloudFront cache before CloudFront forwards another request
          to your origin to determine whether the object has been updated. Only
          effective in the presence of `Cache-Control max-age`, `Cache-Control
          s-maxage`, and `Expires` headers.
          """
          return pulumi.get(self, "max_ttl")
  
      @property
      @pulumi.getter(name="minTtl")
      def min_ttl(self) -> Optional[int]:
          """
          The minimum amount of time that you want objects to
          stay in CloudFront caches before CloudFront queries your origin to see
          whether the object has been updated. Defaults to 0 seconds.
          """
          return pulumi.get(self, "min_ttl")
  
      @property
      @pulumi.getter(name="originRequestPolicyId")
      def origin_request_policy_id(self) -> Optional[str]:
          """
          The unique identifier of the origin request policy
          that is attached to the behavior.
          """
          return pulumi.get(self, "origin_request_policy_id")
  
      @property
      @pulumi.getter(name="realtimeLogConfigArn")
      def realtime_log_config_arn(self) -> Optional[str]:
          """
          The ARN of the real-time log configuration
          that is attached to this cache behavior.
          """
          return pulumi.get(self, "realtime_log_config_arn")
  
      @property
      @pulumi.getter(name="responseHeadersPolicyId")
      def response_headers_policy_id(self) -> Optional[str]:
          """
          The identifier for a response headers policy.
          """
          return pulumi.get(self, "response_headers_policy_id")
  
      @property
      @pulumi.getter(name="smoothStreaming")
      def smooth_streaming(self) -> Optional[bool]:
          """
          Indicates whether you want to distribute
          media files in Microsoft Smooth Streaming format using the origin that is
          associated with this cache behavior.
          """
          return pulumi.get(self, "smooth_streaming")
  
      @property
      @pulumi.getter(name="trustedKeyGroups")
      def trusted_key_groups(self) -> Optional[Sequence[str]]:
          """
          A list of key group IDs that CloudFront can use to validate signed URLs or signed cookies.
          See the [CloudFront User Guide](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-trusted-signers.html) for more information about this feature.
          """
          return pulumi.get(self, "trusted_key_groups")
  
      @property
      @pulumi.getter(name="trustedSigners")
      def trusted_signers(self) -> Optional[Sequence[str]]:
          """
          List of AWS account IDs (or `self`) that you want to allow to create signed URLs for private content.
          See the [CloudFront User Guide](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-trusted-signers.html) for more information about this feature.
          """
          return pulumi.get(self, "trusted_signers")
  
  
  @pulumi.output_type
  class DistributionDefaultCacheBehaviorForwardedValues(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "queryString":
              suggest = "query_string"
          elif key == "queryStringCacheKeys":
              suggest = "query_string_cache_keys"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionDefaultCacheBehaviorForwardedValues. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionDefaultCacheBehaviorForwardedValues.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionDefaultCacheBehaviorForwardedValues.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   cookies: 'outputs.DistributionDefaultCacheBehaviorForwardedValuesCookies',
                   query_string: bool,
                   headers: Optional[Sequence[str]] = None,
                   query_string_cache_keys: Optional[Sequence[str]] = None):
          """
          :param 'DistributionDefaultCacheBehaviorForwardedValuesCookiesArgs' cookies: The forwarded values cookies
                 that specifies how CloudFront handles cookies (maximum one).
          :param bool query_string: Indicates whether you want CloudFront to forward
                 query strings to the origin that is associated with this cache behavior.
          :param Sequence[str] headers: Specifies the Headers, if any, that you want
                 CloudFront to vary upon for this cache behavior. Specify `*` to include all
                 headers.
          :param Sequence[str] query_string_cache_keys: When specified, along with a value of
                 `true` for `query_string`, all query strings are forwarded, however only the
                 query string keys listed in this argument are cached. When omitted with a
                 value of `true` for `query_string`, all query string keys are cached.
          """
          pulumi.set(__self__, "cookies", cookies)
          pulumi.set(__self__, "query_string", query_string)
          if headers is not None:
              pulumi.set(__self__, "headers", headers)
          if query_string_cache_keys is not None:
              pulumi.set(__self__, "query_string_cache_keys", query_string_cache_keys)
  
      @property
      @pulumi.getter
      def cookies(self) -> 'outputs.DistributionDefaultCacheBehaviorForwardedValuesCookies':
          """
          The forwarded values cookies
          that specifies how CloudFront handles cookies (maximum one).
          """
          return pulumi.get(self, "cookies")
  
      @property
      @pulumi.getter(name="queryString")
      def query_string(self) -> bool:
          """
          Indicates whether you want CloudFront to forward
          query strings to the origin that is associated with this cache behavior.
          """
          return pulumi.get(self, "query_string")
  
      @property
      @pulumi.getter
      def headers(self) -> Optional[Sequence[str]]:
          """
          Specifies the Headers, if any, that you want
          CloudFront to vary upon for this cache behavior. Specify `*` to include all
          headers.
          """
          return pulumi.get(self, "headers")
  
      @property
      @pulumi.getter(name="queryStringCacheKeys")
      def query_string_cache_keys(self) -> Optional[Sequence[str]]:
          """
          When specified, along with a value of
          `true` for `query_string`, all query strings are forwarded, however only the
          query string keys listed in this argument are cached. When omitted with a
          value of `true` for `query_string`, all query string keys are cached.
          """
          return pulumi.get(self, "query_string_cache_keys")
  
  
  @pulumi.output_type
  class DistributionDefaultCacheBehaviorForwardedValuesCookies(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "whitelistedNames":
              suggest = "whitelisted_names"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionDefaultCacheBehaviorForwardedValuesCookies. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionDefaultCacheBehaviorForwardedValuesCookies.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionDefaultCacheBehaviorForwardedValuesCookies.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   forward: str,
                   whitelisted_names: Optional[Sequence[str]] = None):
          """
          :param str forward: Specifies whether you want CloudFront to forward
                 cookies to the origin that is associated with this cache behavior. You can
                 specify `all`, `none` or `whitelist`. If `whitelist`, you must include the
                 subsequent `whitelisted_names`
          :param Sequence[str] whitelisted_names: If you have specified `whitelist` to
                 `forward`, the whitelisted cookies that you want CloudFront to forward to
                 your origin.
          """
          pulumi.set(__self__, "forward", forward)
          if whitelisted_names is not None:
              pulumi.set(__self__, "whitelisted_names", whitelisted_names)
  
      @property
      @pulumi.getter
      def forward(self) -> str:
          """
          Specifies whether you want CloudFront to forward
          cookies to the origin that is associated with this cache behavior. You can
          specify `all`, `none` or `whitelist`. If `whitelist`, you must include the
          subsequent `whitelisted_names`
          """
          return pulumi.get(self, "forward")
  
      @property
      @pulumi.getter(name="whitelistedNames")
      def whitelisted_names(self) -> Optional[Sequence[str]]:
          """
          If you have specified `whitelist` to
          `forward`, the whitelisted cookies that you want CloudFront to forward to
          your origin.
          """
          return pulumi.get(self, "whitelisted_names")
  
  
  @pulumi.output_type
  class DistributionDefaultCacheBehaviorFunctionAssociation(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "eventType":
              suggest = "event_type"
          elif key == "functionArn":
              suggest = "function_arn"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionDefaultCacheBehaviorFunctionAssociation. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionDefaultCacheBehaviorFunctionAssociation.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionDefaultCacheBehaviorFunctionAssociation.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   event_type: str,
                   function_arn: str):
          """
          :param str event_type: The specific event to trigger this function.
                 Valid values: `viewer-request` or `viewer-response`
          :param str function_arn: ARN of the Cloudfront function.
          """
          pulumi.set(__self__, "event_type", event_type)
          pulumi.set(__self__, "function_arn", function_arn)
  
      @property
      @pulumi.getter(name="eventType")
      def event_type(self) -> str:
          """
          The specific event to trigger this function.
          Valid values: `viewer-request` or `viewer-response`
          """
          return pulumi.get(self, "event_type")
  
      @property
      @pulumi.getter(name="functionArn")
      def function_arn(self) -> str:
          """
          ARN of the Cloudfront function.
          """
          return pulumi.get(self, "function_arn")
  
  
  @pulumi.output_type
  class DistributionDefaultCacheBehaviorLambdaFunctionAssociation(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "eventType":
              suggest = "event_type"
          elif key == "lambdaArn":
              suggest = "lambda_arn"
          elif key == "includeBody":
              suggest = "include_body"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionDefaultCacheBehaviorLambdaFunctionAssociation. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionDefaultCacheBehaviorLambdaFunctionAssociation.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionDefaultCacheBehaviorLambdaFunctionAssociation.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   event_type: str,
                   lambda_arn: str,
                   include_body: Optional[bool] = None):
          """
          :param str event_type: The specific event to trigger this function.
                 Valid values: `viewer-request` or `viewer-response`
          :param str lambda_arn: ARN of the Lambda function.
          :param bool include_body: When set to true it exposes the request body to the lambda function. Defaults to false. Valid values: `true`, `false`.
          """
          pulumi.set(__self__, "event_type", event_type)
          pulumi.set(__self__, "lambda_arn", lambda_arn)
          if include_body is not None:
              pulumi.set(__self__, "include_body", include_body)
  
      @property
      @pulumi.getter(name="eventType")
      def event_type(self) -> str:
          """
          The specific event to trigger this function.
          Valid values: `viewer-request` or `viewer-response`
          """
          return pulumi.get(self, "event_type")
  
      @property
      @pulumi.getter(name="lambdaArn")
      def lambda_arn(self) -> str:
          """
          ARN of the Lambda function.
          """
          return pulumi.get(self, "lambda_arn")
  
      @property
      @pulumi.getter(name="includeBody")
      def include_body(self) -> Optional[bool]:
          """
          When set to true it exposes the request body to the lambda function. Defaults to false. Valid values: `true`, `false`.
          """
          return pulumi.get(self, "include_body")
  
  
  @pulumi.output_type
  class DistributionLoggingConfig(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "includeCookies":
              suggest = "include_cookies"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionLoggingConfig. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionLoggingConfig.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionLoggingConfig.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   bucket: str,
                   include_cookies: Optional[bool] = None,
                   prefix: Optional[str] = None):
          """
          :param str bucket: The Amazon S3 bucket to store the access logs in, for
                 example, `myawslogbucket.s3.amazonaws.com`.
          :param bool include_cookies: Specifies whether you want CloudFront to
                 include cookies in access logs (default: `false`).
          :param str prefix: An optional string that you want CloudFront to prefix
                 to the access log filenames for this distribution, for example, `myprefix/`.
          """
          pulumi.set(__self__, "bucket", bucket)
          if include_cookies is not None:
              pulumi.set(__self__, "include_cookies", include_cookies)
          if prefix is not None:
              pulumi.set(__self__, "prefix", prefix)
  
      @property
      @pulumi.getter
      def bucket(self) -> str:
          """
          The Amazon S3 bucket to store the access logs in, for
          example, `myawslogbucket.s3.amazonaws.com`.
          """
          return pulumi.get(self, "bucket")
  
      @property
      @pulumi.getter(name="includeCookies")
      def include_cookies(self) -> Optional[bool]:
          """
          Specifies whether you want CloudFront to
          include cookies in access logs (default: `false`).
          """
          return pulumi.get(self, "include_cookies")
  
      @property
      @pulumi.getter
      def prefix(self) -> Optional[str]:
          """
          An optional string that you want CloudFront to prefix
          to the access log filenames for this distribution, for example, `myprefix/`.
          """
          return pulumi.get(self, "prefix")
  
  
  @pulumi.output_type
  class DistributionOrderedCacheBehavior(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "allowedMethods":
              suggest = "allowed_methods"
          elif key == "cachedMethods":
              suggest = "cached_methods"
          elif key == "pathPattern":
              suggest = "path_pattern"
          elif key == "targetOriginId":
              suggest = "target_origin_id"
          elif key == "viewerProtocolPolicy":
              suggest = "viewer_protocol_policy"
          elif key == "cachePolicyId":
              suggest = "cache_policy_id"
          elif key == "defaultTtl":
              suggest = "default_ttl"
          elif key == "fieldLevelEncryptionId":
              suggest = "field_level_encryption_id"
          elif key == "forwardedValues":
              suggest = "forwarded_values"
          elif key == "functionAssociations":
              suggest = "function_associations"
          elif key == "lambdaFunctionAssociations":
              suggest = "lambda_function_associations"
          elif key == "maxTtl":
              suggest = "max_ttl"
          elif key == "minTtl":
              suggest = "min_ttl"
          elif key == "originRequestPolicyId":
              suggest = "origin_request_policy_id"
          elif key == "realtimeLogConfigArn":
              suggest = "realtime_log_config_arn"
          elif key == "responseHeadersPolicyId":
              suggest = "response_headers_policy_id"
          elif key == "smoothStreaming":
              suggest = "smooth_streaming"
          elif key == "trustedKeyGroups":
              suggest = "trusted_key_groups"
          elif key == "trustedSigners":
              suggest = "trusted_signers"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionOrderedCacheBehavior. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionOrderedCacheBehavior.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionOrderedCacheBehavior.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   allowed_methods: Sequence[str],
                   cached_methods: Sequence[str],
                   path_pattern: str,
                   target_origin_id: str,
                   viewer_protocol_policy: str,
                   cache_policy_id: Optional[str] = None,
                   compress: Optional[bool] = None,
                   default_ttl: Optional[int] = None,
                   field_level_encryption_id: Optional[str] = None,
                   forwarded_values: Optional['outputs.DistributionOrderedCacheBehaviorForwardedValues'] = None,
                   function_associations: Optional[Sequence['outputs.DistributionOrderedCacheBehaviorFunctionAssociation']] = None,
                   lambda_function_associations: Optional[Sequence['outputs.DistributionOrderedCacheBehaviorLambdaFunctionAssociation']] = None,
                   max_ttl: Optional[int] = None,
                   min_ttl: Optional[int] = None,
                   origin_request_policy_id: Optional[str] = None,
                   realtime_log_config_arn: Optional[str] = None,
                   response_headers_policy_id: Optional[str] = None,
                   smooth_streaming: Optional[bool] = None,
                   trusted_key_groups: Optional[Sequence[str]] = None,
                   trusted_signers: Optional[Sequence[str]] = None):
          """
          :param Sequence[str] allowed_methods: Controls which HTTP methods CloudFront
                 processes and forwards to your Amazon S3 bucket or your custom origin.
          :param Sequence[str] cached_methods: Controls whether CloudFront caches the
                 response to requests using the specified HTTP methods.
          :param str path_pattern: The pattern (for example, `images/*.jpg`) that
                 specifies which requests you want this cache behavior to apply to.
          :param str target_origin_id: The value of ID for the origin that you want
                 CloudFront to route requests to when a request matches the path pattern
                 either for a cache behavior or for the default cache behavior.
          :param str viewer_protocol_policy: Use this element to specify the
                 protocol that users can use to access the files in the origin specified by
                 TargetOriginId when a request matches the path pattern in PathPattern. One
                 of `allow-all`, `https-only`, or `redirect-to-https`.
          :param str cache_policy_id: The unique identifier of the cache policy that
                 is attached to the cache behavior.
          :param bool compress: Whether you want CloudFront to automatically
                 compress content for web requests that include `Accept-Encoding: gzip` in
                 the request header (default: `false`).
          :param int default_ttl: The default amount of time (in seconds) that an
                 object is in a CloudFront cache before CloudFront forwards another request
                 in the absence of an `Cache-Control max-age` or `Expires` header.
          :param str field_level_encryption_id: Field level encryption configuration ID
          :param 'DistributionOrderedCacheBehaviorForwardedValuesArgs' forwarded_values: The forwarded values configuration that specifies how CloudFront
                 handles query strings, cookies and headers (maximum one).
          :param Sequence['DistributionOrderedCacheBehaviorFunctionAssociationArgs'] function_associations: A config block that triggers a cloudfront
                 function with specific actions (maximum 2).
          :param Sequence['DistributionOrderedCacheBehaviorLambdaFunctionAssociationArgs'] lambda_function_associations: A config block that triggers a lambda
                 function with specific actions (maximum 4).
          :param int max_ttl: The maximum amount of time (in seconds) that an
                 object is in a CloudFront cache before CloudFront forwards another request
                 to your origin to determine whether the object has been updated. Only
                 effective in the presence of `Cache-Control max-age`, `Cache-Control
                 s-maxage`, and `Expires` headers.
          :param int min_ttl: The minimum amount of time that you want objects to
                 stay in CloudFront caches before CloudFront queries your origin to see
                 whether the object has been updated. Defaults to 0 seconds.
          :param str origin_request_policy_id: The unique identifier of the origin request policy
                 that is attached to the behavior.
          :param str realtime_log_config_arn: The ARN of the real-time log configuration
                 that is attached to this cache behavior.
          :param str response_headers_policy_id: The identifier for a response headers policy.
          :param bool smooth_streaming: Indicates whether you want to distribute
                 media files in Microsoft Smooth Streaming format using the origin that is
                 associated with this cache behavior.
          :param Sequence[str] trusted_key_groups: A list of key group IDs that CloudFront can use to validate signed URLs or signed cookies.
                 See the [CloudFront User Guide](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-trusted-signers.html) for more information about this feature.
          :param Sequence[str] trusted_signers: List of AWS account IDs (or `self`) that you want to allow to create signed URLs for private content.
                 See the [CloudFront User Guide](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-trusted-signers.html) for more information about this feature.
          """
          pulumi.set(__self__, "allowed_methods", allowed_methods)
          pulumi.set(__self__, "cached_methods", cached_methods)
          pulumi.set(__self__, "path_pattern", path_pattern)
          pulumi.set(__self__, "target_origin_id", target_origin_id)
          pulumi.set(__self__, "viewer_protocol_policy", viewer_protocol_policy)
          if cache_policy_id is not None:
              pulumi.set(__self__, "cache_policy_id", cache_policy_id)
          if compress is not None:
              pulumi.set(__self__, "compress", compress)
          if default_ttl is not None:
              pulumi.set(__self__, "default_ttl", default_ttl)
          if field_level_encryption_id is not None:
              pulumi.set(__self__, "field_level_encryption_id", field_level_encryption_id)
          if forwarded_values is not None:
              pulumi.set(__self__, "forwarded_values", forwarded_values)
          if function_associations is not None:
              pulumi.set(__self__, "function_associations", function_associations)
          if lambda_function_associations is not None:
              pulumi.set(__self__, "lambda_function_associations", lambda_function_associations)
          if max_ttl is not None:
              pulumi.set(__self__, "max_ttl", max_ttl)
          if min_ttl is not None:
              pulumi.set(__self__, "min_ttl", min_ttl)
          if origin_request_policy_id is not None:
              pulumi.set(__self__, "origin_request_policy_id", origin_request_policy_id)
          if realtime_log_config_arn is not None:
              pulumi.set(__self__, "realtime_log_config_arn", realtime_log_config_arn)
          if response_headers_policy_id is not None:
              pulumi.set(__self__, "response_headers_policy_id", response_headers_policy_id)
          if smooth_streaming is not None:
              pulumi.set(__self__, "smooth_streaming", smooth_streaming)
          if trusted_key_groups is not None:
              pulumi.set(__self__, "trusted_key_groups", trusted_key_groups)
          if trusted_signers is not None:
              pulumi.set(__self__, "trusted_signers", trusted_signers)
  
      @property
      @pulumi.getter(name="allowedMethods")
      def allowed_methods(self) -> Sequence[str]:
          """
          Controls which HTTP methods CloudFront
          processes and forwards to your Amazon S3 bucket or your custom origin.
          """
          return pulumi.get(self, "allowed_methods")
  
      @property
      @pulumi.getter(name="cachedMethods")
      def cached_methods(self) -> Sequence[str]:
          """
          Controls whether CloudFront caches the
          response to requests using the specified HTTP methods.
          """
          return pulumi.get(self, "cached_methods")
  
      @property
      @pulumi.getter(name="pathPattern")
      def path_pattern(self) -> str:
          """
          The pattern (for example, `images/*.jpg`) that
          specifies which requests you want this cache behavior to apply to.
          """
          return pulumi.get(self, "path_pattern")
  
      @property
      @pulumi.getter(name="targetOriginId")
      def target_origin_id(self) -> str:
          """
          The value of ID for the origin that you want
          CloudFront to route requests to when a request matches the path pattern
          either for a cache behavior or for the default cache behavior.
          """
          return pulumi.get(self, "target_origin_id")
  
      @property
      @pulumi.getter(name="viewerProtocolPolicy")
      def viewer_protocol_policy(self) -> str:
          """
          Use this element to specify the
          protocol that users can use to access the files in the origin specified by
          TargetOriginId when a request matches the path pattern in PathPattern. One
          of `allow-all`, `https-only`, or `redirect-to-https`.
          """
          return pulumi.get(self, "viewer_protocol_policy")
  
      @property
      @pulumi.getter(name="cachePolicyId")
      def cache_policy_id(self) -> Optional[str]:
          """
          The unique identifier of the cache policy that
          is attached to the cache behavior.
          """
          return pulumi.get(self, "cache_policy_id")
  
      @property
      @pulumi.getter
      def compress(self) -> Optional[bool]:
          """
          Whether you want CloudFront to automatically
          compress content for web requests that include `Accept-Encoding: gzip` in
          the request header (default: `false`).
          """
          return pulumi.get(self, "compress")
  
      @property
      @pulumi.getter(name="defaultTtl")
      def default_ttl(self) -> Optional[int]:
          """
          The default amount of time (in seconds) that an
          object is in a CloudFront cache before CloudFront forwards another request
          in the absence of an `Cache-Control max-age` or `Expires` header.
          """
          return pulumi.get(self, "default_ttl")
  
      @property
      @pulumi.getter(name="fieldLevelEncryptionId")
      def field_level_encryption_id(self) -> Optional[str]:
          """
          Field level encryption configuration ID
          """
          return pulumi.get(self, "field_level_encryption_id")
  
      @property
      @pulumi.getter(name="forwardedValues")
      def forwarded_values(self) -> Optional['outputs.DistributionOrderedCacheBehaviorForwardedValues']:
          """
          The forwarded values configuration that specifies how CloudFront
          handles query strings, cookies and headers (maximum one).
          """
          return pulumi.get(self, "forwarded_values")
  
      @property
      @pulumi.getter(name="functionAssociations")
      def function_associations(self) -> Optional[Sequence['outputs.DistributionOrderedCacheBehaviorFunctionAssociation']]:
          """
          A config block that triggers a cloudfront
          function with specific actions (maximum 2).
          """
          return pulumi.get(self, "function_associations")
  
      @property
      @pulumi.getter(name="lambdaFunctionAssociations")
      def lambda_function_associations(self) -> Optional[Sequence['outputs.DistributionOrderedCacheBehaviorLambdaFunctionAssociation']]:
          """
          A config block that triggers a lambda
          function with specific actions (maximum 4).
          """
          return pulumi.get(self, "lambda_function_associations")
  
      @property
      @pulumi.getter(name="maxTtl")
      def max_ttl(self) -> Optional[int]:
          """
          The maximum amount of time (in seconds) that an
          object is in a CloudFront cache before CloudFront forwards another request
          to your origin to determine whether the object has been updated. Only
          effective in the presence of `Cache-Control max-age`, `Cache-Control
          s-maxage`, and `Expires` headers.
          """
          return pulumi.get(self, "max_ttl")
  
      @property
      @pulumi.getter(name="minTtl")
      def min_ttl(self) -> Optional[int]:
          """
          The minimum amount of time that you want objects to
          stay in CloudFront caches before CloudFront queries your origin to see
          whether the object has been updated. Defaults to 0 seconds.
          """
          return pulumi.get(self, "min_ttl")
  
      @property
      @pulumi.getter(name="originRequestPolicyId")
      def origin_request_policy_id(self) -> Optional[str]:
          """
          The unique identifier of the origin request policy
          that is attached to the behavior.
          """
          return pulumi.get(self, "origin_request_policy_id")
  
      @property
      @pulumi.getter(name="realtimeLogConfigArn")
      def realtime_log_config_arn(self) -> Optional[str]:
          """
          The ARN of the real-time log configuration
          that is attached to this cache behavior.
          """
          return pulumi.get(self, "realtime_log_config_arn")
  
      @property
      @pulumi.getter(name="responseHeadersPolicyId")
      def response_headers_policy_id(self) -> Optional[str]:
          """
          The identifier for a response headers policy.
          """
          return pulumi.get(self, "response_headers_policy_id")
  
      @property
      @pulumi.getter(name="smoothStreaming")
      def smooth_streaming(self) -> Optional[bool]:
          """
          Indicates whether you want to distribute
          media files in Microsoft Smooth Streaming format using the origin that is
          associated with this cache behavior.
          """
          return pulumi.get(self, "smooth_streaming")
  
      @property
      @pulumi.getter(name="trustedKeyGroups")
      def trusted_key_groups(self) -> Optional[Sequence[str]]:
          """
          A list of key group IDs that CloudFront can use to validate signed URLs or signed cookies.
          See the [CloudFront User Guide](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-trusted-signers.html) for more information about this feature.
          """
          return pulumi.get(self, "trusted_key_groups")
  
      @property
      @pulumi.getter(name="trustedSigners")
      def trusted_signers(self) -> Optional[Sequence[str]]:
          """
          List of AWS account IDs (or `self`) that you want to allow to create signed URLs for private content.
          See the [CloudFront User Guide](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-trusted-signers.html) for more information about this feature.
          """
          return pulumi.get(self, "trusted_signers")
  
  
  @pulumi.output_type
  class DistributionOrderedCacheBehaviorForwardedValues(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "queryString":
              suggest = "query_string"
          elif key == "queryStringCacheKeys":
              suggest = "query_string_cache_keys"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionOrderedCacheBehaviorForwardedValues. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionOrderedCacheBehaviorForwardedValues.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionOrderedCacheBehaviorForwardedValues.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   cookies: 'outputs.DistributionOrderedCacheBehaviorForwardedValuesCookies',
                   query_string: bool,
                   headers: Optional[Sequence[str]] = None,
                   query_string_cache_keys: Optional[Sequence[str]] = None):
          """
          :param 'DistributionOrderedCacheBehaviorForwardedValuesCookiesArgs' cookies: The forwarded values cookies
                 that specifies how CloudFront handles cookies (maximum one).
          :param bool query_string: Indicates whether you want CloudFront to forward
                 query strings to the origin that is associated with this cache behavior.
          :param Sequence[str] headers: Specifies the Headers, if any, that you want
                 CloudFront to vary upon for this cache behavior. Specify `*` to include all
                 headers.
          :param Sequence[str] query_string_cache_keys: When specified, along with a value of
                 `true` for `query_string`, all query strings are forwarded, however only the
                 query string keys listed in this argument are cached. When omitted with a
                 value of `true` for `query_string`, all query string keys are cached.
          """
          pulumi.set(__self__, "cookies", cookies)
          pulumi.set(__self__, "query_string", query_string)
          if headers is not None:
              pulumi.set(__self__, "headers", headers)
          if query_string_cache_keys is not None:
              pulumi.set(__self__, "query_string_cache_keys", query_string_cache_keys)
  
      @property
      @pulumi.getter
      def cookies(self) -> 'outputs.DistributionOrderedCacheBehaviorForwardedValuesCookies':
          """
          The forwarded values cookies
          that specifies how CloudFront handles cookies (maximum one).
          """
          return pulumi.get(self, "cookies")
  
      @property
      @pulumi.getter(name="queryString")
      def query_string(self) -> bool:
          """
          Indicates whether you want CloudFront to forward
          query strings to the origin that is associated with this cache behavior.
          """
          return pulumi.get(self, "query_string")
  
      @property
      @pulumi.getter
      def headers(self) -> Optional[Sequence[str]]:
          """
          Specifies the Headers, if any, that you want
          CloudFront to vary upon for this cache behavior. Specify `*` to include all
          headers.
          """
          return pulumi.get(self, "headers")
  
      @property
      @pulumi.getter(name="queryStringCacheKeys")
      def query_string_cache_keys(self) -> Optional[Sequence[str]]:
          """
          When specified, along with a value of
          `true` for `query_string`, all query strings are forwarded, however only the
          query string keys listed in this argument are cached. When omitted with a
          value of `true` for `query_string`, all query string keys are cached.
          """
          return pulumi.get(self, "query_string_cache_keys")
  
  
  @pulumi.output_type
  class DistributionOrderedCacheBehaviorForwardedValuesCookies(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "whitelistedNames":
              suggest = "whitelisted_names"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionOrderedCacheBehaviorForwardedValuesCookies. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionOrderedCacheBehaviorForwardedValuesCookies.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionOrderedCacheBehaviorForwardedValuesCookies.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   forward: str,
                   whitelisted_names: Optional[Sequence[str]] = None):
          """
          :param str forward: Specifies whether you want CloudFront to forward
                 cookies to the origin that is associated with this cache behavior. You can
                 specify `all`, `none` or `whitelist`. If `whitelist`, you must include the
                 subsequent `whitelisted_names`
          :param Sequence[str] whitelisted_names: If you have specified `whitelist` to
                 `forward`, the whitelisted cookies that you want CloudFront to forward to
                 your origin.
          """
          pulumi.set(__self__, "forward", forward)
          if whitelisted_names is not None:
              pulumi.set(__self__, "whitelisted_names", whitelisted_names)
  
      @property
      @pulumi.getter
      def forward(self) -> str:
          """
          Specifies whether you want CloudFront to forward
          cookies to the origin that is associated with this cache behavior. You can
          specify `all`, `none` or `whitelist`. If `whitelist`, you must include the
          subsequent `whitelisted_names`
          """
          return pulumi.get(self, "forward")
  
      @property
      @pulumi.getter(name="whitelistedNames")
      def whitelisted_names(self) -> Optional[Sequence[str]]:
          """
          If you have specified `whitelist` to
          `forward`, the whitelisted cookies that you want CloudFront to forward to
          your origin.
          """
          return pulumi.get(self, "whitelisted_names")
  
  
  @pulumi.output_type
  class DistributionOrderedCacheBehaviorFunctionAssociation(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "eventType":
              suggest = "event_type"
          elif key == "functionArn":
              suggest = "function_arn"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionOrderedCacheBehaviorFunctionAssociation. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionOrderedCacheBehaviorFunctionAssociation.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionOrderedCacheBehaviorFunctionAssociation.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   event_type: str,
                   function_arn: str):
          """
          :param str event_type: The specific event to trigger this function.
                 Valid values: `viewer-request` or `viewer-response`
          :param str function_arn: ARN of the Cloudfront function.
          """
          pulumi.set(__self__, "event_type", event_type)
          pulumi.set(__self__, "function_arn", function_arn)
  
      @property
      @pulumi.getter(name="eventType")
      def event_type(self) -> str:
          """
          The specific event to trigger this function.
          Valid values: `viewer-request` or `viewer-response`
          """
          return pulumi.get(self, "event_type")
  
      @property
      @pulumi.getter(name="functionArn")
      def function_arn(self) -> str:
          """
          ARN of the Cloudfront function.
          """
          return pulumi.get(self, "function_arn")
  
  
  @pulumi.output_type
  class DistributionOrderedCacheBehaviorLambdaFunctionAssociation(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "eventType":
              suggest = "event_type"
          elif key == "lambdaArn":
              suggest = "lambda_arn"
          elif key == "includeBody":
              suggest = "include_body"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionOrderedCacheBehaviorLambdaFunctionAssociation. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionOrderedCacheBehaviorLambdaFunctionAssociation.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionOrderedCacheBehaviorLambdaFunctionAssociation.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   event_type: str,
                   lambda_arn: str,
                   include_body: Optional[bool] = None):
          """
          :param str event_type: The specific event to trigger this function.
                 Valid values: `viewer-request` or `viewer-response`
          :param str lambda_arn: ARN of the Lambda function.
          :param bool include_body: When set to true it exposes the request body to the lambda function. Defaults to false. Valid values: `true`, `false`.
          """
          pulumi.set(__self__, "event_type", event_type)
          pulumi.set(__self__, "lambda_arn", lambda_arn)
          if include_body is not None:
              pulumi.set(__self__, "include_body", include_body)
  
      @property
      @pulumi.getter(name="eventType")
      def event_type(self) -> str:
          """
          The specific event to trigger this function.
          Valid values: `viewer-request` or `viewer-response`
          """
          return pulumi.get(self, "event_type")
  
      @property
      @pulumi.getter(name="lambdaArn")
      def lambda_arn(self) -> str:
          """
          ARN of the Lambda function.
          """
          return pulumi.get(self, "lambda_arn")
  
      @property
      @pulumi.getter(name="includeBody")
      def include_body(self) -> Optional[bool]:
          """
          When set to true it exposes the request body to the lambda function. Defaults to false. Valid values: `true`, `false`.
          """
          return pulumi.get(self, "include_body")
  
  
  @pulumi.output_type
  class DistributionOrigin(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "domainName":
              suggest = "domain_name"
          elif key == "originId":
              suggest = "origin_id"
          elif key == "connectionAttempts":
              suggest = "connection_attempts"
          elif key == "connectionTimeout":
              suggest = "connection_timeout"
          elif key == "customHeaders":
              suggest = "custom_headers"
          elif key == "customOriginConfig":
              suggest = "custom_origin_config"
          elif key == "originPath":
              suggest = "origin_path"
          elif key == "originShield":
              suggest = "origin_shield"
          elif key == "s3OriginConfig":
              suggest = "s3_origin_config"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionOrigin. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionOrigin.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionOrigin.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   domain_name: str,
                   origin_id: str,
                   connection_attempts: Optional[int] = None,
                   connection_timeout: Optional[int] = None,
                   custom_headers: Optional[Sequence['outputs.DistributionOriginCustomHeader']] = None,
                   custom_origin_config: Optional['outputs.DistributionOriginCustomOriginConfig'] = None,
                   origin_path: Optional[str] = None,
                   origin_shield: Optional['outputs.DistributionOriginOriginShield'] = None,
                   s3_origin_config: Optional['outputs.DistributionOriginS3OriginConfig'] = None):
          """
          :param str domain_name: The DNS domain name of either the S3 bucket, or
                 web site of your custom origin.
          :param str origin_id: The unique identifier of the member origin
          :param int connection_attempts: The number of times that CloudFront attempts to connect to the origin. Must be between 1-3. Defaults to 3.
          :param int connection_timeout: The number of seconds that CloudFront waits when trying to establish a connection to the origin. Must be between 1-10. Defaults to 10.
          :param Sequence['DistributionOriginCustomHeaderArgs'] custom_headers: One or more sub-resources with `name` and
                 `value` parameters that specify header data that will be sent to the origin
                 (multiples allowed).
          :param 'DistributionOriginCustomOriginConfigArgs' custom_origin_config: The CloudFront custom
                 origin configuration information. If an S3
                 origin is required, use `s3_origin_config` instead.
          :param str origin_path: An optional element that causes CloudFront to
                 request your content from a directory in your Amazon S3 bucket or your
                 custom origin.
          :param 'DistributionOriginOriginShieldArgs' origin_shield: The CloudFront Origin Shield
                 configuration information. Using Origin Shield can help reduce the load on your origin. For more information, see [Using Origin Shield](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/origin-shield.html) in the Amazon CloudFront Developer Guide.
          :param 'DistributionOriginS3OriginConfigArgs' s3_origin_config: The CloudFront S3 origin
                 configuration information. If a custom origin is required, use
                 `custom_origin_config` instead.
          """
          pulumi.set(__self__, "domain_name", domain_name)
          pulumi.set(__self__, "origin_id", origin_id)
          if connection_attempts is not None:
              pulumi.set(__self__, "connection_attempts", connection_attempts)
          if connection_timeout is not None:
              pulumi.set(__self__, "connection_timeout", connection_timeout)
          if custom_headers is not None:
              pulumi.set(__self__, "custom_headers", custom_headers)
          if custom_origin_config is not None:
              pulumi.set(__self__, "custom_origin_config", custom_origin_config)
          if origin_path is not None:
              pulumi.set(__self__, "origin_path", origin_path)
          if origin_shield is not None:
              pulumi.set(__self__, "origin_shield", origin_shield)
          if s3_origin_config is not None:
              pulumi.set(__self__, "s3_origin_config", s3_origin_config)
  
      @property
      @pulumi.getter(name="domainName")
      def domain_name(self) -> str:
          """
          The DNS domain name of either the S3 bucket, or
          web site of your custom origin.
          """
          return pulumi.get(self, "domain_name")
  
      @property
      @pulumi.getter(name="originId")
      def origin_id(self) -> str:
          """
          The unique identifier of the member origin
          """
          return pulumi.get(self, "origin_id")
  
      @property
      @pulumi.getter(name="connectionAttempts")
      def connection_attempts(self) -> Optional[int]:
          """
          The number of times that CloudFront attempts to connect to the origin. Must be between 1-3. Defaults to 3.
          """
          return pulumi.get(self, "connection_attempts")
  
      @property
      @pulumi.getter(name="connectionTimeout")
      def connection_timeout(self) -> Optional[int]:
          """
          The number of seconds that CloudFront waits when trying to establish a connection to the origin. Must be between 1-10. Defaults to 10.
          """
          return pulumi.get(self, "connection_timeout")
  
      @property
      @pulumi.getter(name="customHeaders")
      def custom_headers(self) -> Optional[Sequence['outputs.DistributionOriginCustomHeader']]:
          """
          One or more sub-resources with `name` and
          `value` parameters that specify header data that will be sent to the origin
          (multiples allowed).
          """
          return pulumi.get(self, "custom_headers")
  
      @property
      @pulumi.getter(name="customOriginConfig")
      def custom_origin_config(self) -> Optional['outputs.DistributionOriginCustomOriginConfig']:
          """
          The CloudFront custom
          origin configuration information. If an S3
          origin is required, use `s3_origin_config` instead.
          """
          return pulumi.get(self, "custom_origin_config")
  
      @property
      @pulumi.getter(name="originPath")
      def origin_path(self) -> Optional[str]:
          """
          An optional element that causes CloudFront to
          request your content from a directory in your Amazon S3 bucket or your
          custom origin.
          """
          return pulumi.get(self, "origin_path")
  
      @property
      @pulumi.getter(name="originShield")
      def origin_shield(self) -> Optional['outputs.DistributionOriginOriginShield']:
          """
          The CloudFront Origin Shield
          configuration information. Using Origin Shield can help reduce the load on your origin. For more information, see [Using Origin Shield](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/origin-shield.html) in the Amazon CloudFront Developer Guide.
          """
          return pulumi.get(self, "origin_shield")
  
      @property
      @pulumi.getter(name="s3OriginConfig")
      def s3_origin_config(self) -> Optional['outputs.DistributionOriginS3OriginConfig']:
          """
          The CloudFront S3 origin
          configuration information. If a custom origin is required, use
          `custom_origin_config` instead.
          """
          return pulumi.get(self, "s3_origin_config")
  
  
  @pulumi.output_type
  class DistributionOriginCustomHeader(dict):
      def __init__(__self__, *,
                   name: str,
                   value: str):
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "value", value)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def value(self) -> str:
          return pulumi.get(self, "value")
  
  
  @pulumi.output_type
  class DistributionOriginCustomOriginConfig(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "httpPort":
              suggest = "http_port"
          elif key == "httpsPort":
              suggest = "https_port"
          elif key == "originProtocolPolicy":
              suggest = "origin_protocol_policy"
          elif key == "originSslProtocols":
              suggest = "origin_ssl_protocols"
          elif key == "originKeepaliveTimeout":
              suggest = "origin_keepalive_timeout"
          elif key == "originReadTimeout":
              suggest = "origin_read_timeout"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionOriginCustomOriginConfig. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionOriginCustomOriginConfig.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionOriginCustomOriginConfig.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   http_port: int,
                   https_port: int,
                   origin_protocol_policy: str,
                   origin_ssl_protocols: Sequence[str],
                   origin_keepalive_timeout: Optional[int] = None,
                   origin_read_timeout: Optional[int] = None):
          """
          :param int http_port: The HTTP port the custom origin listens on.
          :param int https_port: The HTTPS port the custom origin listens on.
          :param str origin_protocol_policy: The origin protocol policy to apply to
                 your origin. One of `http-only`, `https-only`, or `match-viewer`.
          :param Sequence[str] origin_ssl_protocols: The SSL/TLS protocols that you want
                 CloudFront to use when communicating with your origin over HTTPS. A list of
                 one or more of `SSLv3`, `TLSv1`, `TLSv1.1`, and `TLSv1.2`.
          :param int origin_keepalive_timeout: The Custom KeepAlive timeout, in seconds. By default, AWS enforces a limit of `60`. But you can request an [increase](http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/RequestAndResponseBehaviorCustomOrigin.html#request-custom-request-timeout).
          :param int origin_read_timeout: The Custom Read timeout, in seconds. By default, AWS enforces a limit of `60`. But you can request an [increase](http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/RequestAndResponseBehaviorCustomOrigin.html#request-custom-request-timeout).
          """
          pulumi.set(__self__, "http_port", http_port)
          pulumi.set(__self__, "https_port", https_port)
          pulumi.set(__self__, "origin_protocol_policy", origin_protocol_policy)
          pulumi.set(__self__, "origin_ssl_protocols", origin_ssl_protocols)
          if origin_keepalive_timeout is not None:
              pulumi.set(__self__, "origin_keepalive_timeout", origin_keepalive_timeout)
          if origin_read_timeout is not None:
              pulumi.set(__self__, "origin_read_timeout", origin_read_timeout)
  
      @property
      @pulumi.getter(name="httpPort")
      def http_port(self) -> int:
          """
          The HTTP port the custom origin listens on.
          """
          return pulumi.get(self, "http_port")
  
      @property
      @pulumi.getter(name="httpsPort")
      def https_port(self) -> int:
          """
          The HTTPS port the custom origin listens on.
          """
          return pulumi.get(self, "https_port")
  
      @property
      @pulumi.getter(name="originProtocolPolicy")
      def origin_protocol_policy(self) -> str:
          """
          The origin protocol policy to apply to
          your origin. One of `http-only`, `https-only`, or `match-viewer`.
          """
          return pulumi.get(self, "origin_protocol_policy")
  
      @property
      @pulumi.getter(name="originSslProtocols")
      def origin_ssl_protocols(self) -> Sequence[str]:
          """
          The SSL/TLS protocols that you want
          CloudFront to use when communicating with your origin over HTTPS. A list of
          one or more of `SSLv3`, `TLSv1`, `TLSv1.1`, and `TLSv1.2`.
          """
          return pulumi.get(self, "origin_ssl_protocols")
  
      @property
      @pulumi.getter(name="originKeepaliveTimeout")
      def origin_keepalive_timeout(self) -> Optional[int]:
          """
          The Custom KeepAlive timeout, in seconds. By default, AWS enforces a limit of `60`. But you can request an [increase](http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/RequestAndResponseBehaviorCustomOrigin.html#request-custom-request-timeout).
          """
          return pulumi.get(self, "origin_keepalive_timeout")
  
      @property
      @pulumi.getter(name="originReadTimeout")
      def origin_read_timeout(self) -> Optional[int]:
          """
          The Custom Read timeout, in seconds. By default, AWS enforces a limit of `60`. But you can request an [increase](http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/RequestAndResponseBehaviorCustomOrigin.html#request-custom-request-timeout).
          """
          return pulumi.get(self, "origin_read_timeout")
  
  
  @pulumi.output_type
  class DistributionOriginGroup(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "failoverCriteria":
              suggest = "failover_criteria"
          elif key == "originId":
              suggest = "origin_id"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionOriginGroup. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionOriginGroup.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionOriginGroup.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   failover_criteria: 'outputs.DistributionOriginGroupFailoverCriteria',
                   members: Sequence['outputs.DistributionOriginGroupMember'],
                   origin_id: str):
          """
          :param 'DistributionOriginGroupFailoverCriteriaArgs' failover_criteria: The failover criteria for when to failover to the secondary origin
          :param Sequence['DistributionOriginGroupMemberArgs'] members: Ordered member configuration blocks assigned to the origin group, where the first member is the primary origin. You must specify two members.
          :param str origin_id: The unique identifier of the member origin
          """
          pulumi.set(__self__, "failover_criteria", failover_criteria)
          pulumi.set(__self__, "members", members)
          pulumi.set(__self__, "origin_id", origin_id)
  
      @property
      @pulumi.getter(name="failoverCriteria")
      def failover_criteria(self) -> 'outputs.DistributionOriginGroupFailoverCriteria':
          """
          The failover criteria for when to failover to the secondary origin
          """
          return pulumi.get(self, "failover_criteria")
  
      @property
      @pulumi.getter
      def members(self) -> Sequence['outputs.DistributionOriginGroupMember']:
          """
          Ordered member configuration blocks assigned to the origin group, where the first member is the primary origin. You must specify two members.
          """
          return pulumi.get(self, "members")
  
      @property
      @pulumi.getter(name="originId")
      def origin_id(self) -> str:
          """
          The unique identifier of the member origin
          """
          return pulumi.get(self, "origin_id")
  
  
  @pulumi.output_type
  class DistributionOriginGroupFailoverCriteria(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "statusCodes":
              suggest = "status_codes"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionOriginGroupFailoverCriteria. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionOriginGroupFailoverCriteria.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionOriginGroupFailoverCriteria.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   status_codes: Sequence[int]):
          """
          :param Sequence[int] status_codes: A list of HTTP status codes for the origin group
          """
          pulumi.set(__self__, "status_codes", status_codes)
  
      @property
      @pulumi.getter(name="statusCodes")
      def status_codes(self) -> Sequence[int]:
          """
          A list of HTTP status codes for the origin group
          """
          return pulumi.get(self, "status_codes")
  
  
  @pulumi.output_type
  class DistributionOriginGroupMember(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "originId":
              suggest = "origin_id"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionOriginGroupMember. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionOriginGroupMember.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionOriginGroupMember.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   origin_id: str):
          """
          :param str origin_id: The unique identifier of the member origin
          """
          pulumi.set(__self__, "origin_id", origin_id)
  
      @property
      @pulumi.getter(name="originId")
      def origin_id(self) -> str:
          """
          The unique identifier of the member origin
          """
          return pulumi.get(self, "origin_id")
  
  
  @pulumi.output_type
  class DistributionOriginOriginShield(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "originShieldRegion":
              suggest = "origin_shield_region"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionOriginOriginShield. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionOriginOriginShield.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionOriginOriginShield.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   enabled: bool,
                   origin_shield_region: str):
          """
          :param bool enabled: A flag that specifies whether Origin Shield is enabled.
          :param str origin_shield_region: The AWS Region for Origin Shield. To specify a region, use the region code, not the region name. For example, specify the US East (Ohio) region as us-east-2.
          """
          pulumi.set(__self__, "enabled", enabled)
          pulumi.set(__self__, "origin_shield_region", origin_shield_region)
  
      @property
      @pulumi.getter
      def enabled(self) -> bool:
          """
          A flag that specifies whether Origin Shield is enabled.
          """
          return pulumi.get(self, "enabled")
  
      @property
      @pulumi.getter(name="originShieldRegion")
      def origin_shield_region(self) -> str:
          """
          The AWS Region for Origin Shield. To specify a region, use the region code, not the region name. For example, specify the US East (Ohio) region as us-east-2.
          """
          return pulumi.get(self, "origin_shield_region")
  
  
  @pulumi.output_type
  class DistributionOriginS3OriginConfig(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "originAccessIdentity":
              suggest = "origin_access_identity"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionOriginS3OriginConfig. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionOriginS3OriginConfig.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionOriginS3OriginConfig.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   origin_access_identity: str):
          """
          :param str origin_access_identity: The [CloudFront origin access
                 identity][5] to associate with the origin.
          """
          pulumi.set(__self__, "origin_access_identity", origin_access_identity)
  
      @property
      @pulumi.getter(name="originAccessIdentity")
      def origin_access_identity(self) -> str:
          """
          The [CloudFront origin access
          identity][5] to associate with the origin.
          """
          return pulumi.get(self, "origin_access_identity")
  
  
  @pulumi.output_type
  class DistributionRestrictions(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "geoRestriction":
              suggest = "geo_restriction"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionRestrictions. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionRestrictions.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionRestrictions.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   geo_restriction: 'outputs.DistributionRestrictionsGeoRestriction'):
          pulumi.set(__self__, "geo_restriction", geo_restriction)
  
      @property
      @pulumi.getter(name="geoRestriction")
      def geo_restriction(self) -> 'outputs.DistributionRestrictionsGeoRestriction':
          return pulumi.get(self, "geo_restriction")
  
  
  @pulumi.output_type
  class DistributionRestrictionsGeoRestriction(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "restrictionType":
              suggest = "restriction_type"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionRestrictionsGeoRestriction. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionRestrictionsGeoRestriction.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionRestrictionsGeoRestriction.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   restriction_type: str,
                   locations: Optional[Sequence[str]] = None):
          """
          :param str restriction_type: The method that you want to use to restrict
                 distribution of your content by country: `none`, `whitelist`, or
                 `blacklist`.
          :param Sequence[str] locations: The [ISO 3166-1-alpha-2 codes][4] for which you
                 want CloudFront either to distribute your content (`whitelist`) or not
                 distribute your content (`blacklist`).
          """
          pulumi.set(__self__, "restriction_type", restriction_type)
          if locations is not None:
              pulumi.set(__self__, "locations", locations)
  
      @property
      @pulumi.getter(name="restrictionType")
      def restriction_type(self) -> str:
          """
          The method that you want to use to restrict
          distribution of your content by country: `none`, `whitelist`, or
          `blacklist`.
          """
          return pulumi.get(self, "restriction_type")
  
      @property
      @pulumi.getter
      def locations(self) -> Optional[Sequence[str]]:
          """
          The [ISO 3166-1-alpha-2 codes][4] for which you
          want CloudFront either to distribute your content (`whitelist`) or not
          distribute your content (`blacklist`).
          """
          return pulumi.get(self, "locations")
  
  
  @pulumi.output_type
  class DistributionTrustedKeyGroup(dict):
      def __init__(__self__, *,
                   enabled: Optional[bool] = None,
                   items: Optional[Sequence['outputs.DistributionTrustedKeyGroupItem']] = None):
          """
          :param bool enabled: A flag that specifies whether Origin Shield is enabled.
          :param Sequence['DistributionTrustedKeyGroupItemArgs'] items: List of nested attributes for each trusted signer
          """
          if enabled is not None:
              pulumi.set(__self__, "enabled", enabled)
          if items is not None:
              pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def enabled(self) -> Optional[bool]:
          """
          A flag that specifies whether Origin Shield is enabled.
          """
          return pulumi.get(self, "enabled")
  
      @property
      @pulumi.getter
      def items(self) -> Optional[Sequence['outputs.DistributionTrustedKeyGroupItem']]:
          """
          List of nested attributes for each trusted signer
          """
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class DistributionTrustedKeyGroupItem(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "keyGroupId":
              suggest = "key_group_id"
          elif key == "keyPairIds":
              suggest = "key_pair_ids"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionTrustedKeyGroupItem. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionTrustedKeyGroupItem.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionTrustedKeyGroupItem.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   key_group_id: Optional[str] = None,
                   key_pair_ids: Optional[Sequence[str]] = None):
          """
          :param str key_group_id: The ID of the key group that contains the public keys
          :param Sequence[str] key_pair_ids: Set of active CloudFront key pairs associated with the signer account
          """
          if key_group_id is not None:
              pulumi.set(__self__, "key_group_id", key_group_id)
          if key_pair_ids is not None:
              pulumi.set(__self__, "key_pair_ids", key_pair_ids)
  
      @property
      @pulumi.getter(name="keyGroupId")
      def key_group_id(self) -> Optional[str]:
          """
          The ID of the key group that contains the public keys
          """
          return pulumi.get(self, "key_group_id")
  
      @property
      @pulumi.getter(name="keyPairIds")
      def key_pair_ids(self) -> Optional[Sequence[str]]:
          """
          Set of active CloudFront key pairs associated with the signer account
          """
          return pulumi.get(self, "key_pair_ids")
  
  
  @pulumi.output_type
  class DistributionTrustedSigner(dict):
      def __init__(__self__, *,
                   enabled: Optional[bool] = None,
                   items: Optional[Sequence['outputs.DistributionTrustedSignerItem']] = None):
          """
          :param bool enabled: A flag that specifies whether Origin Shield is enabled.
          :param Sequence['DistributionTrustedSignerItemArgs'] items: List of nested attributes for each trusted signer
          """
          if enabled is not None:
              pulumi.set(__self__, "enabled", enabled)
          if items is not None:
              pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def enabled(self) -> Optional[bool]:
          """
          A flag that specifies whether Origin Shield is enabled.
          """
          return pulumi.get(self, "enabled")
  
      @property
      @pulumi.getter
      def items(self) -> Optional[Sequence['outputs.DistributionTrustedSignerItem']]:
          """
          List of nested attributes for each trusted signer
          """
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class DistributionTrustedSignerItem(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "awsAccountNumber":
              suggest = "aws_account_number"
          elif key == "keyPairIds":
              suggest = "key_pair_ids"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionTrustedSignerItem. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionTrustedSignerItem.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionTrustedSignerItem.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   aws_account_number: Optional[str] = None,
                   key_pair_ids: Optional[Sequence[str]] = None):
          """
          :param str aws_account_number: AWS account ID or `self`
          :param Sequence[str] key_pair_ids: Set of active CloudFront key pairs associated with the signer account
          """
          if aws_account_number is not None:
              pulumi.set(__self__, "aws_account_number", aws_account_number)
          if key_pair_ids is not None:
              pulumi.set(__self__, "key_pair_ids", key_pair_ids)
  
      @property
      @pulumi.getter(name="awsAccountNumber")
      def aws_account_number(self) -> Optional[str]:
          """
          AWS account ID or `self`
          """
          return pulumi.get(self, "aws_account_number")
  
      @property
      @pulumi.getter(name="keyPairIds")
      def key_pair_ids(self) -> Optional[Sequence[str]]:
          """
          Set of active CloudFront key pairs associated with the signer account
          """
          return pulumi.get(self, "key_pair_ids")
  
  
  @pulumi.output_type
  class DistributionViewerCertificate(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "acmCertificateArn":
              suggest = "acm_certificate_arn"
          elif key == "cloudfrontDefaultCertificate":
              suggest = "cloudfront_default_certificate"
          elif key == "iamCertificateId":
              suggest = "iam_certificate_id"
          elif key == "minimumProtocolVersion":
              suggest = "minimum_protocol_version"
          elif key == "sslSupportMethod":
              suggest = "ssl_support_method"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in DistributionViewerCertificate. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          DistributionViewerCertificate.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          DistributionViewerCertificate.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   acm_certificate_arn: Optional[str] = None,
                   cloudfront_default_certificate: Optional[bool] = None,
                   iam_certificate_id: Optional[str] = None,
                   minimum_protocol_version: Optional[str] = None,
                   ssl_support_method: Optional[str] = None):
          """
          :param str acm_certificate_arn: The ARN of the [AWS Certificate Manager](https://aws.amazon.com/certificate-manager/)
                 certificate that you wish to use with this distribution. Specify this,
                 `cloudfront_default_certificate`, or `iam_certificate_id`.  The ACM
                 certificate must be in  US-EAST-1.
          :param bool cloudfront_default_certificate: `true` if you want viewers to use HTTPS
                 to request your objects and you're using the CloudFront domain name for your
                 distribution. Specify this, `acm_certificate_arn`, or `iam_certificate_id`.
          :param str iam_certificate_id: The IAM certificate identifier of the custom viewer
                 certificate for this distribution if you are using a custom domain. Specify
                 this, `acm_certificate_arn`, or `cloudfront_default_certificate`.
          :param str minimum_protocol_version: The minimum version of the SSL protocol that
                 you want CloudFront to use for HTTPS connections. Can only be set if
                 `cloudfront_default_certificate = false`. See all possible values in
                 [this](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/secure-connections-supported-viewer-protocols-ciphers.html)
                 table under "Security policy." Some examples include: `TLSv1.2_2019` and
                 `TLSv1.2_2021`. Default: `TLSv1`. **NOTE**:
                 If you are using a custom certificate (specified with `acm_certificate_arn`
                 or `iam_certificate_id`), and have specified `sni-only` in
                 `ssl_support_method`, `TLSv1` or later must be specified. If you have
                 specified `vip` in `ssl_support_method`, only `SSLv3` or `TLSv1` can be
                 specified. If you have specified `cloudfront_default_certificate`, `TLSv1`
                 must be specified.
          """
          if acm_certificate_arn is not None:
              pulumi.set(__self__, "acm_certificate_arn", acm_certificate_arn)
          if cloudfront_default_certificate is not None:
              pulumi.set(__self__, "cloudfront_default_certificate", cloudfront_default_certificate)
          if iam_certificate_id is not None:
              pulumi.set(__self__, "iam_certificate_id", iam_certificate_id)
          if minimum_protocol_version is not None:
              pulumi.set(__self__, "minimum_protocol_version", minimum_protocol_version)
          if ssl_support_method is not None:
              pulumi.set(__self__, "ssl_support_method", ssl_support_method)
  
      @property
      @pulumi.getter(name="acmCertificateArn")
      def acm_certificate_arn(self) -> Optional[str]:
          """
          The ARN of the [AWS Certificate Manager](https://aws.amazon.com/certificate-manager/)
          certificate that you wish to use with this distribution. Specify this,
          `cloudfront_default_certificate`, or `iam_certificate_id`.  The ACM
          certificate must be in  US-EAST-1.
          """
          return pulumi.get(self, "acm_certificate_arn")
  
      @property
      @pulumi.getter(name="cloudfrontDefaultCertificate")
      def cloudfront_default_certificate(self) -> Optional[bool]:
          """
          `true` if you want viewers to use HTTPS
          to request your objects and you're using the CloudFront domain name for your
          distribution. Specify this, `acm_certificate_arn`, or `iam_certificate_id`.
          """
          return pulumi.get(self, "cloudfront_default_certificate")
  
      @property
      @pulumi.getter(name="iamCertificateId")
      def iam_certificate_id(self) -> Optional[str]:
          """
          The IAM certificate identifier of the custom viewer
          certificate for this distribution if you are using a custom domain. Specify
          this, `acm_certificate_arn`, or `cloudfront_default_certificate`.
          """
          return pulumi.get(self, "iam_certificate_id")
  
      @property
      @pulumi.getter(name="minimumProtocolVersion")
      def minimum_protocol_version(self) -> Optional[str]:
          """
          The minimum version of the SSL protocol that
          you want CloudFront to use for HTTPS connections. Can only be set if
          `cloudfront_default_certificate = false`. See all possible values in
          [this](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/secure-connections-supported-viewer-protocols-ciphers.html)
          table under "Security policy." Some examples include: `TLSv1.2_2019` and
          `TLSv1.2_2021`. Default: `TLSv1`. **NOTE**:
          If you are using a custom certificate (specified with `acm_certificate_arn`
          or `iam_certificate_id`), and have specified `sni-only` in
          `ssl_support_method`, `TLSv1` or later must be specified. If you have
          specified `vip` in `ssl_support_method`, only `SSLv3` or `TLSv1` can be
          specified. If you have specified `cloudfront_default_certificate`, `TLSv1`
          must be specified.
          """
          return pulumi.get(self, "minimum_protocol_version")
  
      @property
      @pulumi.getter(name="sslSupportMethod")
      def ssl_support_method(self) -> Optional[str]:
          return pulumi.get(self, "ssl_support_method")
  
  
  @pulumi.output_type
  class MonitoringSubscriptionMonitoringSubscription(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "realtimeMetricsSubscriptionConfig":
              suggest = "realtime_metrics_subscription_config"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in MonitoringSubscriptionMonitoringSubscription. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          MonitoringSubscriptionMonitoringSubscription.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          MonitoringSubscriptionMonitoringSubscription.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   realtime_metrics_subscription_config: 'outputs.MonitoringSubscriptionMonitoringSubscriptionRealtimeMetricsSubscriptionConfig'):
          """
          :param 'MonitoringSubscriptionMonitoringSubscriptionRealtimeMetricsSubscriptionConfigArgs' realtime_metrics_subscription_config: A subscription configuration for additional CloudWatch metrics. See below.
          """
          pulumi.set(__self__, "realtime_metrics_subscription_config", realtime_metrics_subscription_config)
  
      @property
      @pulumi.getter(name="realtimeMetricsSubscriptionConfig")
      def realtime_metrics_subscription_config(self) -> 'outputs.MonitoringSubscriptionMonitoringSubscriptionRealtimeMetricsSubscriptionConfig':
          """
          A subscription configuration for additional CloudWatch metrics. See below.
          """
          return pulumi.get(self, "realtime_metrics_subscription_config")
  
  
  @pulumi.output_type
  class MonitoringSubscriptionMonitoringSubscriptionRealtimeMetricsSubscriptionConfig(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "realtimeMetricsSubscriptionStatus":
              suggest = "realtime_metrics_subscription_status"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in MonitoringSubscriptionMonitoringSubscriptionRealtimeMetricsSubscriptionConfig. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          MonitoringSubscriptionMonitoringSubscriptionRealtimeMetricsSubscriptionConfig.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          MonitoringSubscriptionMonitoringSubscriptionRealtimeMetricsSubscriptionConfig.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   realtime_metrics_subscription_status: str):
          """
          :param str realtime_metrics_subscription_status: A flag that indicates whether additional CloudWatch metrics are enabled for a given CloudFront distribution. Valid values are `Enabled` and `Disabled`. See below.
          """
          pulumi.set(__self__, "realtime_metrics_subscription_status", realtime_metrics_subscription_status)
  
      @property
      @pulumi.getter(name="realtimeMetricsSubscriptionStatus")
      def realtime_metrics_subscription_status(self) -> str:
          """
          A flag that indicates whether additional CloudWatch metrics are enabled for a given CloudFront distribution. Valid values are `Enabled` and `Disabled`. See below.
          """
          return pulumi.get(self, "realtime_metrics_subscription_status")
  
  
  @pulumi.output_type
  class OriginRequestPolicyCookiesConfig(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "cookieBehavior":
              suggest = "cookie_behavior"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in OriginRequestPolicyCookiesConfig. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          OriginRequestPolicyCookiesConfig.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          OriginRequestPolicyCookiesConfig.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   cookie_behavior: str,
                   cookies: Optional['outputs.OriginRequestPolicyCookiesConfigCookies'] = None):
          pulumi.set(__self__, "cookie_behavior", cookie_behavior)
          if cookies is not None:
              pulumi.set(__self__, "cookies", cookies)
  
      @property
      @pulumi.getter(name="cookieBehavior")
      def cookie_behavior(self) -> str:
          return pulumi.get(self, "cookie_behavior")
  
      @property
      @pulumi.getter
      def cookies(self) -> Optional['outputs.OriginRequestPolicyCookiesConfigCookies']:
          return pulumi.get(self, "cookies")
  
  
  @pulumi.output_type
  class OriginRequestPolicyCookiesConfigCookies(dict):
      def __init__(__self__, *,
                   items: Optional[Sequence[str]] = None):
          if items is not None:
              pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Optional[Sequence[str]]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class OriginRequestPolicyHeadersConfig(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "headerBehavior":
              suggest = "header_behavior"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in OriginRequestPolicyHeadersConfig. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          OriginRequestPolicyHeadersConfig.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          OriginRequestPolicyHeadersConfig.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   header_behavior: Optional[str] = None,
                   headers: Optional['outputs.OriginRequestPolicyHeadersConfigHeaders'] = None):
          if header_behavior is not None:
              pulumi.set(__self__, "header_behavior", header_behavior)
          if headers is not None:
              pulumi.set(__self__, "headers", headers)
  
      @property
      @pulumi.getter(name="headerBehavior")
      def header_behavior(self) -> Optional[str]:
          return pulumi.get(self, "header_behavior")
  
      @property
      @pulumi.getter
      def headers(self) -> Optional['outputs.OriginRequestPolicyHeadersConfigHeaders']:
          return pulumi.get(self, "headers")
  
  
  @pulumi.output_type
  class OriginRequestPolicyHeadersConfigHeaders(dict):
      def __init__(__self__, *,
                   items: Optional[Sequence[str]] = None):
          if items is not None:
              pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Optional[Sequence[str]]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class OriginRequestPolicyQueryStringsConfig(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "queryStringBehavior":
              suggest = "query_string_behavior"
          elif key == "queryStrings":
              suggest = "query_strings"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in OriginRequestPolicyQueryStringsConfig. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          OriginRequestPolicyQueryStringsConfig.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          OriginRequestPolicyQueryStringsConfig.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   query_string_behavior: str,
                   query_strings: Optional['outputs.OriginRequestPolicyQueryStringsConfigQueryStrings'] = None):
          pulumi.set(__self__, "query_string_behavior", query_string_behavior)
          if query_strings is not None:
              pulumi.set(__self__, "query_strings", query_strings)
  
      @property
      @pulumi.getter(name="queryStringBehavior")
      def query_string_behavior(self) -> str:
          return pulumi.get(self, "query_string_behavior")
  
      @property
      @pulumi.getter(name="queryStrings")
      def query_strings(self) -> Optional['outputs.OriginRequestPolicyQueryStringsConfigQueryStrings']:
          return pulumi.get(self, "query_strings")
  
  
  @pulumi.output_type
  class OriginRequestPolicyQueryStringsConfigQueryStrings(dict):
      def __init__(__self__, *,
                   items: Optional[Sequence[str]] = None):
          if items is not None:
              pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Optional[Sequence[str]]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class RealtimeLogConfigEndpoint(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "kinesisStreamConfig":
              suggest = "kinesis_stream_config"
          elif key == "streamType":
              suggest = "stream_type"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in RealtimeLogConfigEndpoint. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          RealtimeLogConfigEndpoint.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          RealtimeLogConfigEndpoint.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   kinesis_stream_config: 'outputs.RealtimeLogConfigEndpointKinesisStreamConfig',
                   stream_type: str):
          """
          :param 'RealtimeLogConfigEndpointKinesisStreamConfigArgs' kinesis_stream_config: The Amazon Kinesis data stream configuration.
          :param str stream_type: The type of data stream where real-time log data is sent. The only valid value is `Kinesis`.
          """
          pulumi.set(__self__, "kinesis_stream_config", kinesis_stream_config)
          pulumi.set(__self__, "stream_type", stream_type)
  
      @property
      @pulumi.getter(name="kinesisStreamConfig")
      def kinesis_stream_config(self) -> 'outputs.RealtimeLogConfigEndpointKinesisStreamConfig':
          """
          The Amazon Kinesis data stream configuration.
          """
          return pulumi.get(self, "kinesis_stream_config")
  
      @property
      @pulumi.getter(name="streamType")
      def stream_type(self) -> str:
          """
          The type of data stream where real-time log data is sent. The only valid value is `Kinesis`.
          """
          return pulumi.get(self, "stream_type")
  
  
  @pulumi.output_type
  class RealtimeLogConfigEndpointKinesisStreamConfig(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "roleArn":
              suggest = "role_arn"
          elif key == "streamArn":
              suggest = "stream_arn"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in RealtimeLogConfigEndpointKinesisStreamConfig. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          RealtimeLogConfigEndpointKinesisStreamConfig.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          RealtimeLogConfigEndpointKinesisStreamConfig.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   role_arn: str,
                   stream_arn: str):
          """
          :param str role_arn: The ARN of an IAM role that CloudFront can use to send real-time log data to the Kinesis data stream.
                 See the [AWS documentation](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/real-time-logs.html#understand-real-time-log-config-iam-role) for more information.
          :param str stream_arn: The ARN of the Kinesis data stream.
          """
          pulumi.set(__self__, "role_arn", role_arn)
          pulumi.set(__self__, "stream_arn", stream_arn)
  
      @property
      @pulumi.getter(name="roleArn")
      def role_arn(self) -> str:
          """
          The ARN of an IAM role that CloudFront can use to send real-time log data to the Kinesis data stream.
          See the [AWS documentation](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/real-time-logs.html#understand-real-time-log-config-iam-role) for more information.
          """
          return pulumi.get(self, "role_arn")
  
      @property
      @pulumi.getter(name="streamArn")
      def stream_arn(self) -> str:
          """
          The ARN of the Kinesis data stream.
          """
          return pulumi.get(self, "stream_arn")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicyCorsConfig(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "accessControlAllowCredentials":
              suggest = "access_control_allow_credentials"
          elif key == "accessControlAllowHeaders":
              suggest = "access_control_allow_headers"
          elif key == "accessControlAllowMethods":
              suggest = "access_control_allow_methods"
          elif key == "accessControlAllowOrigins":
              suggest = "access_control_allow_origins"
          elif key == "originOverride":
              suggest = "origin_override"
          elif key == "accessControlExposeHeaders":
              suggest = "access_control_expose_headers"
          elif key == "accessControlMaxAgeSec":
              suggest = "access_control_max_age_sec"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in ResponseHeadersPolicyCorsConfig. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          ResponseHeadersPolicyCorsConfig.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          ResponseHeadersPolicyCorsConfig.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   access_control_allow_credentials: bool,
                   access_control_allow_headers: 'outputs.ResponseHeadersPolicyCorsConfigAccessControlAllowHeaders',
                   access_control_allow_methods: 'outputs.ResponseHeadersPolicyCorsConfigAccessControlAllowMethods',
                   access_control_allow_origins: 'outputs.ResponseHeadersPolicyCorsConfigAccessControlAllowOrigins',
                   origin_override: bool,
                   access_control_expose_headers: Optional['outputs.ResponseHeadersPolicyCorsConfigAccessControlExposeHeaders'] = None,
                   access_control_max_age_sec: Optional[int] = None):
          """
          :param bool access_control_allow_credentials: A Boolean value that CloudFront uses as the value for the Access-Control-Allow-Credentials HTTP response header.
          :param 'ResponseHeadersPolicyCorsConfigAccessControlAllowHeadersArgs' access_control_allow_headers: Object that contains an attribute `items` that contains a list of HTTP header names that CloudFront includes as values for the Access-Control-Allow-Headers HTTP response header.
          :param 'ResponseHeadersPolicyCorsConfigAccessControlAllowMethodsArgs' access_control_allow_methods: Object that contains an attribute `items` that contains a list of HTTP methods that CloudFront includes as values for the Access-Control-Allow-Methods HTTP response header. Valid values: `GET` | `POST` | `OPTIONS` | `PUT` | `DELETE` | `HEAD` | `ALL`
          :param 'ResponseHeadersPolicyCorsConfigAccessControlAllowOriginsArgs' access_control_allow_origins: Object that contains an attribute `items` that contains a list of origins that CloudFront can use as the value for the Access-Control-Allow-Origin HTTP response header.
          :param 'ResponseHeadersPolicyCorsConfigAccessControlExposeHeadersArgs' access_control_expose_headers: Object that contains an attribute `items` that contains a list of HTTP headers that CloudFront includes as values for the Access-Control-Expose-Headers HTTP response header.
          :param int access_control_max_age_sec: A number that CloudFront uses as the value for the max-age directive in the Strict-Transport-Security HTTP response header.
          """
          pulumi.set(__self__, "access_control_allow_credentials", access_control_allow_credentials)
          pulumi.set(__self__, "access_control_allow_headers", access_control_allow_headers)
          pulumi.set(__self__, "access_control_allow_methods", access_control_allow_methods)
          pulumi.set(__self__, "access_control_allow_origins", access_control_allow_origins)
          pulumi.set(__self__, "origin_override", origin_override)
          if access_control_expose_headers is not None:
              pulumi.set(__self__, "access_control_expose_headers", access_control_expose_headers)
          if access_control_max_age_sec is not None:
              pulumi.set(__self__, "access_control_max_age_sec", access_control_max_age_sec)
  
      @property
      @pulumi.getter(name="accessControlAllowCredentials")
      def access_control_allow_credentials(self) -> bool:
          """
          A Boolean value that CloudFront uses as the value for the Access-Control-Allow-Credentials HTTP response header.
          """
          return pulumi.get(self, "access_control_allow_credentials")
  
      @property
      @pulumi.getter(name="accessControlAllowHeaders")
      def access_control_allow_headers(self) -> 'outputs.ResponseHeadersPolicyCorsConfigAccessControlAllowHeaders':
          """
          Object that contains an attribute `items` that contains a list of HTTP header names that CloudFront includes as values for the Access-Control-Allow-Headers HTTP response header.
          """
          return pulumi.get(self, "access_control_allow_headers")
  
      @property
      @pulumi.getter(name="accessControlAllowMethods")
      def access_control_allow_methods(self) -> 'outputs.ResponseHeadersPolicyCorsConfigAccessControlAllowMethods':
          """
          Object that contains an attribute `items` that contains a list of HTTP methods that CloudFront includes as values for the Access-Control-Allow-Methods HTTP response header. Valid values: `GET` | `POST` | `OPTIONS` | `PUT` | `DELETE` | `HEAD` | `ALL`
          """
          return pulumi.get(self, "access_control_allow_methods")
  
      @property
      @pulumi.getter(name="accessControlAllowOrigins")
      def access_control_allow_origins(self) -> 'outputs.ResponseHeadersPolicyCorsConfigAccessControlAllowOrigins':
          """
          Object that contains an attribute `items` that contains a list of origins that CloudFront can use as the value for the Access-Control-Allow-Origin HTTP response header.
          """
          return pulumi.get(self, "access_control_allow_origins")
  
      @property
      @pulumi.getter(name="originOverride")
      def origin_override(self) -> bool:
          return pulumi.get(self, "origin_override")
  
      @property
      @pulumi.getter(name="accessControlExposeHeaders")
      def access_control_expose_headers(self) -> Optional['outputs.ResponseHeadersPolicyCorsConfigAccessControlExposeHeaders']:
          """
          Object that contains an attribute `items` that contains a list of HTTP headers that CloudFront includes as values for the Access-Control-Expose-Headers HTTP response header.
          """
          return pulumi.get(self, "access_control_expose_headers")
  
      @property
      @pulumi.getter(name="accessControlMaxAgeSec")
      def access_control_max_age_sec(self) -> Optional[int]:
          """
          A number that CloudFront uses as the value for the max-age directive in the Strict-Transport-Security HTTP response header.
          """
          return pulumi.get(self, "access_control_max_age_sec")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicyCorsConfigAccessControlAllowHeaders(dict):
      def __init__(__self__, *,
                   items: Optional[Sequence[str]] = None):
          if items is not None:
              pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Optional[Sequence[str]]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicyCorsConfigAccessControlAllowMethods(dict):
      def __init__(__self__, *,
                   items: Optional[Sequence[str]] = None):
          if items is not None:
              pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Optional[Sequence[str]]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicyCorsConfigAccessControlAllowOrigins(dict):
      def __init__(__self__, *,
                   items: Optional[Sequence[str]] = None):
          if items is not None:
              pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Optional[Sequence[str]]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicyCorsConfigAccessControlExposeHeaders(dict):
      def __init__(__self__, *,
                   items: Optional[Sequence[str]] = None):
          if items is not None:
              pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Optional[Sequence[str]]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicyCustomHeadersConfig(dict):
      def __init__(__self__, *,
                   items: Optional[Sequence['outputs.ResponseHeadersPolicyCustomHeadersConfigItem']] = None):
          if items is not None:
              pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Optional[Sequence['outputs.ResponseHeadersPolicyCustomHeadersConfigItem']]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicyCustomHeadersConfigItem(dict):
      def __init__(__self__, *,
                   header: str,
                   override: bool,
                   value: str):
          """
          :param str header: The HTTP response header name.
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          :param str value: The value for the HTTP response header.
          """
          pulumi.set(__self__, "header", header)
          pulumi.set(__self__, "override", override)
          pulumi.set(__self__, "value", value)
  
      @property
      @pulumi.getter
      def header(self) -> str:
          """
          The HTTP response header name.
          """
          return pulumi.get(self, "header")
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
      @property
      @pulumi.getter
      def value(self) -> str:
          """
          The value for the HTTP response header.
          """
          return pulumi.get(self, "value")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicySecurityHeadersConfig(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "contentSecurityPolicy":
              suggest = "content_security_policy"
          elif key == "contentTypeOptions":
              suggest = "content_type_options"
          elif key == "frameOptions":
              suggest = "frame_options"
          elif key == "referrerPolicy":
              suggest = "referrer_policy"
          elif key == "strictTransportSecurity":
              suggest = "strict_transport_security"
          elif key == "xssProtection":
              suggest = "xss_protection"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in ResponseHeadersPolicySecurityHeadersConfig. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          ResponseHeadersPolicySecurityHeadersConfig.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          ResponseHeadersPolicySecurityHeadersConfig.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   content_security_policy: Optional['outputs.ResponseHeadersPolicySecurityHeadersConfigContentSecurityPolicy'] = None,
                   content_type_options: Optional['outputs.ResponseHeadersPolicySecurityHeadersConfigContentTypeOptions'] = None,
                   frame_options: Optional['outputs.ResponseHeadersPolicySecurityHeadersConfigFrameOptions'] = None,
                   referrer_policy: Optional['outputs.ResponseHeadersPolicySecurityHeadersConfigReferrerPolicy'] = None,
                   strict_transport_security: Optional['outputs.ResponseHeadersPolicySecurityHeadersConfigStrictTransportSecurity'] = None,
                   xss_protection: Optional['outputs.ResponseHeadersPolicySecurityHeadersConfigXssProtection'] = None):
          """
          :param 'ResponseHeadersPolicySecurityHeadersConfigContentSecurityPolicyArgs' content_security_policy: TThe policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.
          :param 'ResponseHeadersPolicySecurityHeadersConfigContentTypeOptionsArgs' content_type_options: TA setting that determines whether CloudFront includes the X-Content-Type-Options HTTP response header with its value set to nosniff. See Content Type Options for more information.
          :param 'ResponseHeadersPolicySecurityHeadersConfigFrameOptionsArgs' frame_options: TA setting that determines whether CloudFront includes the X-Frame-Options HTTP response header and the header’s value. See Frame Options for more information.
          :param 'ResponseHeadersPolicySecurityHeadersConfigReferrerPolicyArgs' referrer_policy: The value of the Referrer-Policy HTTP response header. Valid Values: `no-referrer` | `no-referrer-when-downgrade` | `origin` | `origin-when-cross-origin` | `same-origin` | `strict-origin` | `strict-origin-when-cross-origin` | `unsafe-url`
          :param 'ResponseHeadersPolicySecurityHeadersConfigXssProtectionArgs' xss_protection: TSettings that determine whether CloudFront includes the X-XSS-Protection HTTP response header and the header’s value. See XSS Protection for more information.
          """
          if content_security_policy is not None:
              pulumi.set(__self__, "content_security_policy", content_security_policy)
          if content_type_options is not None:
              pulumi.set(__self__, "content_type_options", content_type_options)
          if frame_options is not None:
              pulumi.set(__self__, "frame_options", frame_options)
          if referrer_policy is not None:
              pulumi.set(__self__, "referrer_policy", referrer_policy)
          if strict_transport_security is not None:
              pulumi.set(__self__, "strict_transport_security", strict_transport_security)
          if xss_protection is not None:
              pulumi.set(__self__, "xss_protection", xss_protection)
  
      @property
      @pulumi.getter(name="contentSecurityPolicy")
      def content_security_policy(self) -> Optional['outputs.ResponseHeadersPolicySecurityHeadersConfigContentSecurityPolicy']:
          """
          TThe policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.
          """
          return pulumi.get(self, "content_security_policy")
  
      @property
      @pulumi.getter(name="contentTypeOptions")
      def content_type_options(self) -> Optional['outputs.ResponseHeadersPolicySecurityHeadersConfigContentTypeOptions']:
          """
          TA setting that determines whether CloudFront includes the X-Content-Type-Options HTTP response header with its value set to nosniff. See Content Type Options for more information.
          """
          return pulumi.get(self, "content_type_options")
  
      @property
      @pulumi.getter(name="frameOptions")
      def frame_options(self) -> Optional['outputs.ResponseHeadersPolicySecurityHeadersConfigFrameOptions']:
          """
          TA setting that determines whether CloudFront includes the X-Frame-Options HTTP response header and the header’s value. See Frame Options for more information.
          """
          return pulumi.get(self, "frame_options")
  
      @property
      @pulumi.getter(name="referrerPolicy")
      def referrer_policy(self) -> Optional['outputs.ResponseHeadersPolicySecurityHeadersConfigReferrerPolicy']:
          """
          The value of the Referrer-Policy HTTP response header. Valid Values: `no-referrer` | `no-referrer-when-downgrade` | `origin` | `origin-when-cross-origin` | `same-origin` | `strict-origin` | `strict-origin-when-cross-origin` | `unsafe-url`
          """
          return pulumi.get(self, "referrer_policy")
  
      @property
      @pulumi.getter(name="strictTransportSecurity")
      def strict_transport_security(self) -> Optional['outputs.ResponseHeadersPolicySecurityHeadersConfigStrictTransportSecurity']:
          return pulumi.get(self, "strict_transport_security")
  
      @property
      @pulumi.getter(name="xssProtection")
      def xss_protection(self) -> Optional['outputs.ResponseHeadersPolicySecurityHeadersConfigXssProtection']:
          """
          TSettings that determine whether CloudFront includes the X-XSS-Protection HTTP response header and the header’s value. See XSS Protection for more information.
          """
          return pulumi.get(self, "xss_protection")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicySecurityHeadersConfigContentSecurityPolicy(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "contentSecurityPolicy":
              suggest = "content_security_policy"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in ResponseHeadersPolicySecurityHeadersConfigContentSecurityPolicy. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          ResponseHeadersPolicySecurityHeadersConfigContentSecurityPolicy.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          ResponseHeadersPolicySecurityHeadersConfigContentSecurityPolicy.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   content_security_policy: str,
                   override: bool):
          """
          :param str content_security_policy: TThe policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          pulumi.set(__self__, "content_security_policy", content_security_policy)
          pulumi.set(__self__, "override", override)
  
      @property
      @pulumi.getter(name="contentSecurityPolicy")
      def content_security_policy(self) -> str:
          """
          TThe policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.
          """
          return pulumi.get(self, "content_security_policy")
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicySecurityHeadersConfigContentTypeOptions(dict):
      def __init__(__self__, *,
                   override: bool):
          """
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          pulumi.set(__self__, "override", override)
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicySecurityHeadersConfigFrameOptions(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "frameOption":
              suggest = "frame_option"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in ResponseHeadersPolicySecurityHeadersConfigFrameOptions. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          ResponseHeadersPolicySecurityHeadersConfigFrameOptions.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          ResponseHeadersPolicySecurityHeadersConfigFrameOptions.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   frame_option: str,
                   override: bool):
          """
          :param str frame_option: The value of the X-Frame-Options HTTP response header. Valid values: `DENY` | `SAMEORIGIN`
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          pulumi.set(__self__, "frame_option", frame_option)
          pulumi.set(__self__, "override", override)
  
      @property
      @pulumi.getter(name="frameOption")
      def frame_option(self) -> str:
          """
          The value of the X-Frame-Options HTTP response header. Valid values: `DENY` | `SAMEORIGIN`
          """
          return pulumi.get(self, "frame_option")
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicySecurityHeadersConfigReferrerPolicy(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "referrerPolicy":
              suggest = "referrer_policy"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in ResponseHeadersPolicySecurityHeadersConfigReferrerPolicy. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          ResponseHeadersPolicySecurityHeadersConfigReferrerPolicy.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          ResponseHeadersPolicySecurityHeadersConfigReferrerPolicy.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   override: bool,
                   referrer_policy: str):
          """
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          :param str referrer_policy: The value of the Referrer-Policy HTTP response header. Valid Values: `no-referrer` | `no-referrer-when-downgrade` | `origin` | `origin-when-cross-origin` | `same-origin` | `strict-origin` | `strict-origin-when-cross-origin` | `unsafe-url`
          """
          pulumi.set(__self__, "override", override)
          pulumi.set(__self__, "referrer_policy", referrer_policy)
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
      @property
      @pulumi.getter(name="referrerPolicy")
      def referrer_policy(self) -> str:
          """
          The value of the Referrer-Policy HTTP response header. Valid Values: `no-referrer` | `no-referrer-when-downgrade` | `origin` | `origin-when-cross-origin` | `same-origin` | `strict-origin` | `strict-origin-when-cross-origin` | `unsafe-url`
          """
          return pulumi.get(self, "referrer_policy")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicySecurityHeadersConfigStrictTransportSecurity(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "accessControlMaxAgeSec":
              suggest = "access_control_max_age_sec"
          elif key == "includeSubdomains":
              suggest = "include_subdomains"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in ResponseHeadersPolicySecurityHeadersConfigStrictTransportSecurity. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          ResponseHeadersPolicySecurityHeadersConfigStrictTransportSecurity.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          ResponseHeadersPolicySecurityHeadersConfigStrictTransportSecurity.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   access_control_max_age_sec: int,
                   override: bool,
                   include_subdomains: Optional[bool] = None,
                   preload: Optional[bool] = None):
          """
          :param int access_control_max_age_sec: A number that CloudFront uses as the value for the max-age directive in the Strict-Transport-Security HTTP response header.
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          :param bool include_subdomains: A Boolean value that determines whether CloudFront includes the includeSubDomains directive in the Strict-Transport-Security HTTP response header.
          :param bool preload: A Boolean value that determines whether CloudFront includes the preload directive in the Strict-Transport-Security HTTP response header.
          """
          pulumi.set(__self__, "access_control_max_age_sec", access_control_max_age_sec)
          pulumi.set(__self__, "override", override)
          if include_subdomains is not None:
              pulumi.set(__self__, "include_subdomains", include_subdomains)
          if preload is not None:
              pulumi.set(__self__, "preload", preload)
  
      @property
      @pulumi.getter(name="accessControlMaxAgeSec")
      def access_control_max_age_sec(self) -> int:
          """
          A number that CloudFront uses as the value for the max-age directive in the Strict-Transport-Security HTTP response header.
          """
          return pulumi.get(self, "access_control_max_age_sec")
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
      @property
      @pulumi.getter(name="includeSubdomains")
      def include_subdomains(self) -> Optional[bool]:
          """
          A Boolean value that determines whether CloudFront includes the includeSubDomains directive in the Strict-Transport-Security HTTP response header.
          """
          return pulumi.get(self, "include_subdomains")
  
      @property
      @pulumi.getter
      def preload(self) -> Optional[bool]:
          """
          A Boolean value that determines whether CloudFront includes the preload directive in the Strict-Transport-Security HTTP response header.
          """
          return pulumi.get(self, "preload")
  
  
  @pulumi.output_type
  class ResponseHeadersPolicySecurityHeadersConfigXssProtection(dict):
      @staticmethod
      def __key_warning(key: str):
          suggest = None
          if key == "modeBlock":
              suggest = "mode_block"
          elif key == "reportUri":
              suggest = "report_uri"
  
          if suggest:
              pulumi.log.warn(f"Key '{key}' not found in ResponseHeadersPolicySecurityHeadersConfigXssProtection. Access the value via the '{suggest}' property getter instead.")
  
      def __getitem__(self, key: str) -> Any:
          ResponseHeadersPolicySecurityHeadersConfigXssProtection.__key_warning(key)
          return super().__getitem__(key)
  
      def get(self, key: str, default = None) -> Any:
          ResponseHeadersPolicySecurityHeadersConfigXssProtection.__key_warning(key)
          return super().get(key, default)
  
      def __init__(__self__, *,
                   override: bool,
                   protection: bool,
                   mode_block: Optional[bool] = None,
                   report_uri: Optional[str] = None):
          """
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          :param bool protection: A Boolean value that determines the value of the X-XSS-Protection HTTP response header. When this setting is true, the value of the X-XSS-Protection header is 1. When this setting is false, the value of the X-XSS-Protection header is 0.
          :param bool mode_block: A Boolean value that determines whether CloudFront includes the mode=block directive in the X-XSS-Protection header.
          :param str report_uri: A Boolean value that determines whether CloudFront sets a reporting URI in the X-XSS-Protection header.
          """
          pulumi.set(__self__, "override", override)
          pulumi.set(__self__, "protection", protection)
          if mode_block is not None:
              pulumi.set(__self__, "mode_block", mode_block)
          if report_uri is not None:
              pulumi.set(__self__, "report_uri", report_uri)
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
      @property
      @pulumi.getter
      def protection(self) -> bool:
          """
          A Boolean value that determines the value of the X-XSS-Protection HTTP response header. When this setting is true, the value of the X-XSS-Protection header is 1. When this setting is false, the value of the X-XSS-Protection header is 0.
          """
          return pulumi.get(self, "protection")
  
      @property
      @pulumi.getter(name="modeBlock")
      def mode_block(self) -> Optional[bool]:
          """
          A Boolean value that determines whether CloudFront includes the mode=block directive in the X-XSS-Protection header.
          """
          return pulumi.get(self, "mode_block")
  
      @property
      @pulumi.getter(name="reportUri")
      def report_uri(self) -> Optional[str]:
          """
          A Boolean value that determines whether CloudFront sets a reporting URI in the X-XSS-Protection header.
          """
          return pulumi.get(self, "report_uri")
  
  
  @pulumi.output_type
  class GetCachePolicyParametersInCacheKeyAndForwardedToOriginResult(dict):
      def __init__(__self__, *,
                   cookies_configs: Sequence['outputs.GetCachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigResult'],
                   enable_accept_encoding_brotli: bool,
                   enable_accept_encoding_gzip: bool,
                   headers_configs: Sequence['outputs.GetCachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigResult'],
                   query_strings_configs: Sequence['outputs.GetCachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigResult']):
          """
          :param Sequence['GetCachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigArgs'] cookies_configs: Object that determines whether any cookies in viewer requests (and if so, which cookies) are included in the cache key and automatically included in requests that CloudFront sends to the origin. See Cookies Config for more information.
          :param bool enable_accept_encoding_brotli: A flag that can affect whether the Accept-Encoding HTTP header is included in the cache key and included in requests that CloudFront sends to the origin.
          :param bool enable_accept_encoding_gzip: A flag that can affect whether the Accept-Encoding HTTP header is included in the cache key and included in requests that CloudFront sends to the origin.
          :param Sequence['GetCachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigArgs'] headers_configs: Object that determines whether any HTTP headers (and if so, which headers) are included in the cache key and automatically included in requests that CloudFront sends to the origin. See Headers Config for more information.
          :param Sequence['GetCachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigArgs'] query_strings_configs: Object that determines whether any URL query strings in viewer requests (and if so, which query strings) are included in the cache key and automatically included in requests that CloudFront sends to the origin. See Query Strings Config for more information.
          """
          pulumi.set(__self__, "cookies_configs", cookies_configs)
          pulumi.set(__self__, "enable_accept_encoding_brotli", enable_accept_encoding_brotli)
          pulumi.set(__self__, "enable_accept_encoding_gzip", enable_accept_encoding_gzip)
          pulumi.set(__self__, "headers_configs", headers_configs)
          pulumi.set(__self__, "query_strings_configs", query_strings_configs)
  
      @property
      @pulumi.getter(name="cookiesConfigs")
      def cookies_configs(self) -> Sequence['outputs.GetCachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigResult']:
          """
          Object that determines whether any cookies in viewer requests (and if so, which cookies) are included in the cache key and automatically included in requests that CloudFront sends to the origin. See Cookies Config for more information.
          """
          return pulumi.get(self, "cookies_configs")
  
      @property
      @pulumi.getter(name="enableAcceptEncodingBrotli")
      def enable_accept_encoding_brotli(self) -> bool:
          """
          A flag that can affect whether the Accept-Encoding HTTP header is included in the cache key and included in requests that CloudFront sends to the origin.
          """
          return pulumi.get(self, "enable_accept_encoding_brotli")
  
      @property
      @pulumi.getter(name="enableAcceptEncodingGzip")
      def enable_accept_encoding_gzip(self) -> bool:
          """
          A flag that can affect whether the Accept-Encoding HTTP header is included in the cache key and included in requests that CloudFront sends to the origin.
          """
          return pulumi.get(self, "enable_accept_encoding_gzip")
  
      @property
      @pulumi.getter(name="headersConfigs")
      def headers_configs(self) -> Sequence['outputs.GetCachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigResult']:
          """
          Object that determines whether any HTTP headers (and if so, which headers) are included in the cache key and automatically included in requests that CloudFront sends to the origin. See Headers Config for more information.
          """
          return pulumi.get(self, "headers_configs")
  
      @property
      @pulumi.getter(name="queryStringsConfigs")
      def query_strings_configs(self) -> Sequence['outputs.GetCachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigResult']:
          """
          Object that determines whether any URL query strings in viewer requests (and if so, which query strings) are included in the cache key and automatically included in requests that CloudFront sends to the origin. See Query Strings Config for more information.
          """
          return pulumi.get(self, "query_strings_configs")
  
  
  @pulumi.output_type
  class GetCachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigResult(dict):
      def __init__(__self__, *,
                   cookie_behavior: str,
                   cookies: Sequence['outputs.GetCachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigCookieResult']):
          """
          :param str cookie_behavior: Determines whether any cookies in viewer requests are included in the cache key and automatically included in requests that CloudFront sends to the origin. Valid values are `none`, `whitelist`, `allExcept`, `all`.
          :param Sequence['GetCachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigCookieArgs'] cookies: Object that contains a list of cookie names. See Items for more information.
          """
          pulumi.set(__self__, "cookie_behavior", cookie_behavior)
          pulumi.set(__self__, "cookies", cookies)
  
      @property
      @pulumi.getter(name="cookieBehavior")
      def cookie_behavior(self) -> str:
          """
          Determines whether any cookies in viewer requests are included in the cache key and automatically included in requests that CloudFront sends to the origin. Valid values are `none`, `whitelist`, `allExcept`, `all`.
          """
          return pulumi.get(self, "cookie_behavior")
  
      @property
      @pulumi.getter
      def cookies(self) -> Sequence['outputs.GetCachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigCookieResult']:
          """
          Object that contains a list of cookie names. See Items for more information.
          """
          return pulumi.get(self, "cookies")
  
  
  @pulumi.output_type
  class GetCachePolicyParametersInCacheKeyAndForwardedToOriginCookiesConfigCookieResult(dict):
      def __init__(__self__, *,
                   items: Sequence[str]):
          """
          :param Sequence[str] items: A list of item names (`cookies`, `headers`, or `query_strings`).
          """
          pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Sequence[str]:
          """
          A list of item names (`cookies`, `headers`, or `query_strings`).
          """
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class GetCachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigResult(dict):
      def __init__(__self__, *,
                   header_behavior: str,
                   headers: Sequence['outputs.GetCachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigHeaderResult']):
          """
          :param str header_behavior: Determines whether any HTTP headers are included in the cache key and automatically included in requests that CloudFront sends to the origin. Valid values are `none`, `whitelist`.
          :param Sequence['GetCachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigHeaderArgs'] headers: Object that contains a list of header names. See Items for more information.
          """
          pulumi.set(__self__, "header_behavior", header_behavior)
          pulumi.set(__self__, "headers", headers)
  
      @property
      @pulumi.getter(name="headerBehavior")
      def header_behavior(self) -> str:
          """
          Determines whether any HTTP headers are included in the cache key and automatically included in requests that CloudFront sends to the origin. Valid values are `none`, `whitelist`.
          """
          return pulumi.get(self, "header_behavior")
  
      @property
      @pulumi.getter
      def headers(self) -> Sequence['outputs.GetCachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigHeaderResult']:
          """
          Object that contains a list of header names. See Items for more information.
          """
          return pulumi.get(self, "headers")
  
  
  @pulumi.output_type
  class GetCachePolicyParametersInCacheKeyAndForwardedToOriginHeadersConfigHeaderResult(dict):
      def __init__(__self__, *,
                   items: Sequence[str]):
          """
          :param Sequence[str] items: A list of item names (`cookies`, `headers`, or `query_strings`).
          """
          pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Sequence[str]:
          """
          A list of item names (`cookies`, `headers`, or `query_strings`).
          """
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class GetCachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigResult(dict):
      def __init__(__self__, *,
                   query_string_behavior: str,
                   query_strings: Sequence['outputs.GetCachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigQueryStringResult']):
          """
          :param str query_string_behavior: Determines whether any URL query strings in viewer requests are included in the cache key and automatically included in requests that CloudFront sends to the origin. Valid values are `none`, `whitelist`, `allExcept`, `all`.
          :param Sequence['GetCachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigQueryStringArgs'] query_strings: Object that contains a list of query string names. See Items for more information.
          """
          pulumi.set(__self__, "query_string_behavior", query_string_behavior)
          pulumi.set(__self__, "query_strings", query_strings)
  
      @property
      @pulumi.getter(name="queryStringBehavior")
      def query_string_behavior(self) -> str:
          """
          Determines whether any URL query strings in viewer requests are included in the cache key and automatically included in requests that CloudFront sends to the origin. Valid values are `none`, `whitelist`, `allExcept`, `all`.
          """
          return pulumi.get(self, "query_string_behavior")
  
      @property
      @pulumi.getter(name="queryStrings")
      def query_strings(self) -> Sequence['outputs.GetCachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigQueryStringResult']:
          """
          Object that contains a list of query string names. See Items for more information.
          """
          return pulumi.get(self, "query_strings")
  
  
  @pulumi.output_type
  class GetCachePolicyParametersInCacheKeyAndForwardedToOriginQueryStringsConfigQueryStringResult(dict):
      def __init__(__self__, *,
                   items: Sequence[str]):
          """
          :param Sequence[str] items: A list of item names (`cookies`, `headers`, or `query_strings`).
          """
          pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Sequence[str]:
          """
          A list of item names (`cookies`, `headers`, or `query_strings`).
          """
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class GetOriginRequestPolicyCookiesConfigResult(dict):
      def __init__(__self__, *,
                   cookie_behavior: str,
                   cookies: Sequence['outputs.GetOriginRequestPolicyCookiesConfigCookieResult']):
          pulumi.set(__self__, "cookie_behavior", cookie_behavior)
          pulumi.set(__self__, "cookies", cookies)
  
      @property
      @pulumi.getter(name="cookieBehavior")
      def cookie_behavior(self) -> str:
          return pulumi.get(self, "cookie_behavior")
  
      @property
      @pulumi.getter
      def cookies(self) -> Sequence['outputs.GetOriginRequestPolicyCookiesConfigCookieResult']:
          return pulumi.get(self, "cookies")
  
  
  @pulumi.output_type
  class GetOriginRequestPolicyCookiesConfigCookieResult(dict):
      def __init__(__self__, *,
                   items: Sequence[str]):
          pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Sequence[str]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class GetOriginRequestPolicyHeadersConfigResult(dict):
      def __init__(__self__, *,
                   header_behavior: str,
                   headers: Sequence['outputs.GetOriginRequestPolicyHeadersConfigHeaderResult']):
          pulumi.set(__self__, "header_behavior", header_behavior)
          pulumi.set(__self__, "headers", headers)
  
      @property
      @pulumi.getter(name="headerBehavior")
      def header_behavior(self) -> str:
          return pulumi.get(self, "header_behavior")
  
      @property
      @pulumi.getter
      def headers(self) -> Sequence['outputs.GetOriginRequestPolicyHeadersConfigHeaderResult']:
          return pulumi.get(self, "headers")
  
  
  @pulumi.output_type
  class GetOriginRequestPolicyHeadersConfigHeaderResult(dict):
      def __init__(__self__, *,
                   items: Sequence[str]):
          pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Sequence[str]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class GetOriginRequestPolicyQueryStringsConfigResult(dict):
      def __init__(__self__, *,
                   query_string_behavior: str,
                   query_strings: Sequence['outputs.GetOriginRequestPolicyQueryStringsConfigQueryStringResult']):
          pulumi.set(__self__, "query_string_behavior", query_string_behavior)
          pulumi.set(__self__, "query_strings", query_strings)
  
      @property
      @pulumi.getter(name="queryStringBehavior")
      def query_string_behavior(self) -> str:
          return pulumi.get(self, "query_string_behavior")
  
      @property
      @pulumi.getter(name="queryStrings")
      def query_strings(self) -> Sequence['outputs.GetOriginRequestPolicyQueryStringsConfigQueryStringResult']:
          return pulumi.get(self, "query_strings")
  
  
  @pulumi.output_type
  class GetOriginRequestPolicyQueryStringsConfigQueryStringResult(dict):
      def __init__(__self__, *,
                   items: Sequence[str]):
          pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Sequence[str]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class GetResponseHeadersPolicyCorsConfigResult(dict):
      def __init__(__self__, *,
                   access_control_allow_credentials: bool,
                   access_control_allow_headers: Sequence['outputs.GetResponseHeadersPolicyCorsConfigAccessControlAllowHeaderResult'],
                   access_control_allow_methods: Sequence['outputs.GetResponseHeadersPolicyCorsConfigAccessControlAllowMethodResult'],
                   access_control_allow_origins: Sequence['outputs.GetResponseHeadersPolicyCorsConfigAccessControlAllowOriginResult'],
                   access_control_expose_headers: Sequence['outputs.GetResponseHeadersPolicyCorsConfigAccessControlExposeHeaderResult'],
                   access_control_max_age_sec: int,
                   origin_override: bool):
          """
          :param bool access_control_allow_credentials: A Boolean value that CloudFront uses as the value for the Access-Control-Allow-Credentials HTTP response header.
          :param Sequence['GetResponseHeadersPolicyCorsConfigAccessControlAllowHeaderArgs'] access_control_allow_headers: Object that contains an attribute `items` that contains a list of HTTP header names that CloudFront includes as values for the Access-Control-Allow-Headers HTTP response header.
          :param Sequence['GetResponseHeadersPolicyCorsConfigAccessControlAllowMethodArgs'] access_control_allow_methods: Object that contains an attribute `items` that contains a list of HTTP methods that CloudFront includes as values for the Access-Control-Allow-Methods HTTP response header. Valid values: `GET` | `POST` | `OPTIONS` | `PUT` | `DELETE` | `HEAD` | `ALL`
          :param Sequence['GetResponseHeadersPolicyCorsConfigAccessControlAllowOriginArgs'] access_control_allow_origins: Object that contains an attribute `items` that contains a list of origins that CloudFront can use as the value for the Access-Control-Allow-Origin HTTP response header.
          :param Sequence['GetResponseHeadersPolicyCorsConfigAccessControlExposeHeaderArgs'] access_control_expose_headers: Object that contains an attribute `items` that contains a list of HTTP headers that CloudFront includes as values for the Access-Control-Expose-Headers HTTP response header.
          :param int access_control_max_age_sec: A number that CloudFront uses as the value for the max-age directive in the Strict-Transport-Security HTTP response header.
          """
          pulumi.set(__self__, "access_control_allow_credentials", access_control_allow_credentials)
          pulumi.set(__self__, "access_control_allow_headers", access_control_allow_headers)
          pulumi.set(__self__, "access_control_allow_methods", access_control_allow_methods)
          pulumi.set(__self__, "access_control_allow_origins", access_control_allow_origins)
          pulumi.set(__self__, "access_control_expose_headers", access_control_expose_headers)
          pulumi.set(__self__, "access_control_max_age_sec", access_control_max_age_sec)
          pulumi.set(__self__, "origin_override", origin_override)
  
      @property
      @pulumi.getter(name="accessControlAllowCredentials")
      def access_control_allow_credentials(self) -> bool:
          """
          A Boolean value that CloudFront uses as the value for the Access-Control-Allow-Credentials HTTP response header.
          """
          return pulumi.get(self, "access_control_allow_credentials")
  
      @property
      @pulumi.getter(name="accessControlAllowHeaders")
      def access_control_allow_headers(self) -> Sequence['outputs.GetResponseHeadersPolicyCorsConfigAccessControlAllowHeaderResult']:
          """
          Object that contains an attribute `items` that contains a list of HTTP header names that CloudFront includes as values for the Access-Control-Allow-Headers HTTP response header.
          """
          return pulumi.get(self, "access_control_allow_headers")
  
      @property
      @pulumi.getter(name="accessControlAllowMethods")
      def access_control_allow_methods(self) -> Sequence['outputs.GetResponseHeadersPolicyCorsConfigAccessControlAllowMethodResult']:
          """
          Object that contains an attribute `items` that contains a list of HTTP methods that CloudFront includes as values for the Access-Control-Allow-Methods HTTP response header. Valid values: `GET` | `POST` | `OPTIONS` | `PUT` | `DELETE` | `HEAD` | `ALL`
          """
          return pulumi.get(self, "access_control_allow_methods")
  
      @property
      @pulumi.getter(name="accessControlAllowOrigins")
      def access_control_allow_origins(self) -> Sequence['outputs.GetResponseHeadersPolicyCorsConfigAccessControlAllowOriginResult']:
          """
          Object that contains an attribute `items` that contains a list of origins that CloudFront can use as the value for the Access-Control-Allow-Origin HTTP response header.
          """
          return pulumi.get(self, "access_control_allow_origins")
  
      @property
      @pulumi.getter(name="accessControlExposeHeaders")
      def access_control_expose_headers(self) -> Sequence['outputs.GetResponseHeadersPolicyCorsConfigAccessControlExposeHeaderResult']:
          """
          Object that contains an attribute `items` that contains a list of HTTP headers that CloudFront includes as values for the Access-Control-Expose-Headers HTTP response header.
          """
          return pulumi.get(self, "access_control_expose_headers")
  
      @property
      @pulumi.getter(name="accessControlMaxAgeSec")
      def access_control_max_age_sec(self) -> int:
          """
          A number that CloudFront uses as the value for the max-age directive in the Strict-Transport-Security HTTP response header.
          """
          return pulumi.get(self, "access_control_max_age_sec")
  
      @property
      @pulumi.getter(name="originOverride")
      def origin_override(self) -> bool:
          return pulumi.get(self, "origin_override")
  
  
  @pulumi.output_type
  class GetResponseHeadersPolicyCorsConfigAccessControlAllowHeaderResult(dict):
      def __init__(__self__, *,
                   items: Sequence[str]):
          pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Sequence[str]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class GetResponseHeadersPolicyCorsConfigAccessControlAllowMethodResult(dict):
      def __init__(__self__, *,
                   items: Sequence[str]):
          pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Sequence[str]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class GetResponseHeadersPolicyCorsConfigAccessControlAllowOriginResult(dict):
      def __init__(__self__, *,
                   items: Sequence[str]):
          pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Sequence[str]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class GetResponseHeadersPolicyCorsConfigAccessControlExposeHeaderResult(dict):
      def __init__(__self__, *,
                   items: Sequence[str]):
          pulumi.set(__self__, "items", items)
  
      @property
      @pulumi.getter
      def items(self) -> Sequence[str]:
          return pulumi.get(self, "items")
  
  
  @pulumi.output_type
  class GetResponseHeadersPolicyCustomHeadersConfigResult(dict):
      def __init__(__self__, *,
                   header: str,
                   override: bool,
                   value: str):
          """
          :param str header: The HTTP response header name.
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          :param str value: The value for the HTTP response header.
          """
          pulumi.set(__self__, "header", header)
          pulumi.set(__self__, "override", override)
          pulumi.set(__self__, "value", value)
  
      @property
      @pulumi.getter
      def header(self) -> str:
          """
          The HTTP response header name.
          """
          return pulumi.get(self, "header")
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
      @property
      @pulumi.getter
      def value(self) -> str:
          """
          The value for the HTTP response header.
          """
          return pulumi.get(self, "value")
  
  
  @pulumi.output_type
  class GetResponseHeadersPolicySecurityHeadersConfigResult(dict):
      def __init__(__self__, *,
                   content_security_policies: Sequence['outputs.GetResponseHeadersPolicySecurityHeadersConfigContentSecurityPolicyResult'],
                   content_type_options: Sequence['outputs.GetResponseHeadersPolicySecurityHeadersConfigContentTypeOptionResult'],
                   frame_options: Sequence['outputs.GetResponseHeadersPolicySecurityHeadersConfigFrameOptionResult'],
                   referrer_policies: Sequence['outputs.GetResponseHeadersPolicySecurityHeadersConfigReferrerPolicyResult'],
                   strict_transport_securities: Sequence['outputs.GetResponseHeadersPolicySecurityHeadersConfigStrictTransportSecurityResult'],
                   xss_protections: Sequence['outputs.GetResponseHeadersPolicySecurityHeadersConfigXssProtectionResult']):
          """
          :param Sequence['GetResponseHeadersPolicySecurityHeadersConfigContentSecurityPolicyArgs'] content_security_policies: The policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.
          :param Sequence['GetResponseHeadersPolicySecurityHeadersConfigContentTypeOptionArgs'] content_type_options: A setting that determines whether CloudFront includes the X-Content-Type-Options HTTP response header with its value set to nosniff. See Content Type Options for more information.
          :param Sequence['GetResponseHeadersPolicySecurityHeadersConfigFrameOptionArgs'] frame_options: A setting that determines whether CloudFront includes the X-Frame-Options HTTP response header and the header’s value. See Frame Options for more information.
          :param Sequence['GetResponseHeadersPolicySecurityHeadersConfigReferrerPolicyArgs'] referrer_policies: The value of the Referrer-Policy HTTP response header. Valid Values: `no-referrer` | `no-referrer-when-downgrade` | `origin` | `origin-when-cross-origin` | `same-origin` | `strict-origin` | `strict-origin-when-cross-origin` | `unsafe-url`
          :param Sequence['GetResponseHeadersPolicySecurityHeadersConfigStrictTransportSecurityArgs'] strict_transport_securities: Settings that determine whether CloudFront includes the Strict-Transport-Security HTTP response header and the header’s value. See Strict Transport Security for more information.
          :param Sequence['GetResponseHeadersPolicySecurityHeadersConfigXssProtectionArgs'] xss_protections: Settings that determine whether CloudFront includes the X-XSS-Protection HTTP response header and the header’s value. See XSS Protection for more information.
          """
          pulumi.set(__self__, "content_security_policies", content_security_policies)
          pulumi.set(__self__, "content_type_options", content_type_options)
          pulumi.set(__self__, "frame_options", frame_options)
          pulumi.set(__self__, "referrer_policies", referrer_policies)
          pulumi.set(__self__, "strict_transport_securities", strict_transport_securities)
          pulumi.set(__self__, "xss_protections", xss_protections)
  
      @property
      @pulumi.getter(name="contentSecurityPolicies")
      def content_security_policies(self) -> Sequence['outputs.GetResponseHeadersPolicySecurityHeadersConfigContentSecurityPolicyResult']:
          """
          The policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.
          """
          return pulumi.get(self, "content_security_policies")
  
      @property
      @pulumi.getter(name="contentTypeOptions")
      def content_type_options(self) -> Sequence['outputs.GetResponseHeadersPolicySecurityHeadersConfigContentTypeOptionResult']:
          """
          A setting that determines whether CloudFront includes the X-Content-Type-Options HTTP response header with its value set to nosniff. See Content Type Options for more information.
          """
          return pulumi.get(self, "content_type_options")
  
      @property
      @pulumi.getter(name="frameOptions")
      def frame_options(self) -> Sequence['outputs.GetResponseHeadersPolicySecurityHeadersConfigFrameOptionResult']:
          """
          A setting that determines whether CloudFront includes the X-Frame-Options HTTP response header and the header’s value. See Frame Options for more information.
          """
          return pulumi.get(self, "frame_options")
  
      @property
      @pulumi.getter(name="referrerPolicies")
      def referrer_policies(self) -> Sequence['outputs.GetResponseHeadersPolicySecurityHeadersConfigReferrerPolicyResult']:
          """
          The value of the Referrer-Policy HTTP response header. Valid Values: `no-referrer` | `no-referrer-when-downgrade` | `origin` | `origin-when-cross-origin` | `same-origin` | `strict-origin` | `strict-origin-when-cross-origin` | `unsafe-url`
          """
          return pulumi.get(self, "referrer_policies")
  
      @property
      @pulumi.getter(name="strictTransportSecurities")
      def strict_transport_securities(self) -> Sequence['outputs.GetResponseHeadersPolicySecurityHeadersConfigStrictTransportSecurityResult']:
          """
          Settings that determine whether CloudFront includes the Strict-Transport-Security HTTP response header and the header’s value. See Strict Transport Security for more information.
          """
          return pulumi.get(self, "strict_transport_securities")
  
      @property
      @pulumi.getter(name="xssProtections")
      def xss_protections(self) -> Sequence['outputs.GetResponseHeadersPolicySecurityHeadersConfigXssProtectionResult']:
          """
          Settings that determine whether CloudFront includes the X-XSS-Protection HTTP response header and the header’s value. See XSS Protection for more information.
          """
          return pulumi.get(self, "xss_protections")
  
  
  @pulumi.output_type
  class GetResponseHeadersPolicySecurityHeadersConfigContentSecurityPolicyResult(dict):
      def __init__(__self__, *,
                   content_security_policy: str,
                   override: bool):
          """
          :param str content_security_policy: The policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          pulumi.set(__self__, "content_security_policy", content_security_policy)
          pulumi.set(__self__, "override", override)
  
      @property
      @pulumi.getter(name="contentSecurityPolicy")
      def content_security_policy(self) -> str:
          """
          The policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.
          """
          return pulumi.get(self, "content_security_policy")
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
  
  @pulumi.output_type
  class GetResponseHeadersPolicySecurityHeadersConfigContentTypeOptionResult(dict):
      def __init__(__self__, *,
                   override: bool):
          """
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          pulumi.set(__self__, "override", override)
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
  
  @pulumi.output_type
  class GetResponseHeadersPolicySecurityHeadersConfigFrameOptionResult(dict):
      def __init__(__self__, *,
                   frame_option: str,
                   override: bool):
          """
          :param str frame_option: The value of the X-Frame-Options HTTP response header. Valid values: `DENY` | `SAMEORIGIN`
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          pulumi.set(__self__, "frame_option", frame_option)
          pulumi.set(__self__, "override", override)
  
      @property
      @pulumi.getter(name="frameOption")
      def frame_option(self) -> str:
          """
          The value of the X-Frame-Options HTTP response header. Valid values: `DENY` | `SAMEORIGIN`
          """
          return pulumi.get(self, "frame_option")
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
  
  @pulumi.output_type
  class GetResponseHeadersPolicySecurityHeadersConfigReferrerPolicyResult(dict):
      def __init__(__self__, *,
                   override: bool,
                   referrer_policy: str):
          """
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          :param str referrer_policy: The value of the Referrer-Policy HTTP response header. Valid Values: `no-referrer` | `no-referrer-when-downgrade` | `origin` | `origin-when-cross-origin` | `same-origin` | `strict-origin` | `strict-origin-when-cross-origin` | `unsafe-url`
          """
          pulumi.set(__self__, "override", override)
          pulumi.set(__self__, "referrer_policy", referrer_policy)
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
      @property
      @pulumi.getter(name="referrerPolicy")
      def referrer_policy(self) -> str:
          """
          The value of the Referrer-Policy HTTP response header. Valid Values: `no-referrer` | `no-referrer-when-downgrade` | `origin` | `origin-when-cross-origin` | `same-origin` | `strict-origin` | `strict-origin-when-cross-origin` | `unsafe-url`
          """
          return pulumi.get(self, "referrer_policy")
  
  
  @pulumi.output_type
  class GetResponseHeadersPolicySecurityHeadersConfigStrictTransportSecurityResult(dict):
      def __init__(__self__, *,
                   access_control_max_age_sec: int,
                   include_subdomains: bool,
                   override: bool,
                   preload: bool):
          """
          :param int access_control_max_age_sec: A number that CloudFront uses as the value for the max-age directive in the Strict-Transport-Security HTTP response header.
          :param bool include_subdomains: A Boolean value that determines whether CloudFront includes the includeSubDomains directive in the Strict-Transport-Security HTTP response header.
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          :param bool preload: A Boolean value that determines whether CloudFront includes the preload directive in the Strict-Transport-Security HTTP response header.
          """
          pulumi.set(__self__, "access_control_max_age_sec", access_control_max_age_sec)
          pulumi.set(__self__, "include_subdomains", include_subdomains)
          pulumi.set(__self__, "override", override)
          pulumi.set(__self__, "preload", preload)
  
      @property
      @pulumi.getter(name="accessControlMaxAgeSec")
      def access_control_max_age_sec(self) -> int:
          """
          A number that CloudFront uses as the value for the max-age directive in the Strict-Transport-Security HTTP response header.
          """
          return pulumi.get(self, "access_control_max_age_sec")
  
      @property
      @pulumi.getter(name="includeSubdomains")
      def include_subdomains(self) -> bool:
          """
          A Boolean value that determines whether CloudFront includes the includeSubDomains directive in the Strict-Transport-Security HTTP response header.
          """
          return pulumi.get(self, "include_subdomains")
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
      @property
      @pulumi.getter
      def preload(self) -> bool:
          """
          A Boolean value that determines whether CloudFront includes the preload directive in the Strict-Transport-Security HTTP response header.
          """
          return pulumi.get(self, "preload")
  
  
  @pulumi.output_type
  class GetResponseHeadersPolicySecurityHeadersConfigXssProtectionResult(dict):
      def __init__(__self__, *,
                   mode_block: bool,
                   override: bool,
                   protection: bool,
                   report_uri: str):
          """
          :param bool mode_block: A Boolean value that determines whether CloudFront includes the mode=block directive in the X-XSS-Protection header.
          :param bool override: A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          :param bool protection: A Boolean value that determines the value of the X-XSS-Protection HTTP response header. When this setting is true, the value of the X-XSS-Protection header is 1. When this setting is false, the value of the X-XSS-Protection header is 0.
          :param str report_uri: A Boolean value that determines whether CloudFront sets a reporting URI in the X-XSS-Protection header.
          """
          pulumi.set(__self__, "mode_block", mode_block)
          pulumi.set(__self__, "override", override)
          pulumi.set(__self__, "protection", protection)
          pulumi.set(__self__, "report_uri", report_uri)
  
      @property
      @pulumi.getter(name="modeBlock")
      def mode_block(self) -> bool:
          """
          A Boolean value that determines whether CloudFront includes the mode=block directive in the X-XSS-Protection header.
          """
          return pulumi.get(self, "mode_block")
  
      @property
      @pulumi.getter
      def override(self) -> bool:
          """
          A Boolean value that determines whether CloudFront overrides the X-XSS-Protection HTTP response header received from the origin with the one specified in this response headers policy.
          """
          return pulumi.get(self, "override")
  
      @property
      @pulumi.getter
      def protection(self) -> bool:
          """
          A Boolean value that determines the value of the X-XSS-Protection HTTP response header. When this setting is true, the value of the X-XSS-Protection header is 1. When this setting is false, the value of the X-XSS-Protection header is 0.
          """
          return pulumi.get(self, "protection")
  
      @property
      @pulumi.getter(name="reportUri")
      def report_uri(self) -> str:
          """
          A Boolean value that determines whether CloudFront sets a reporting URI in the X-XSS-Protection header.
          """
          return pulumi.get(self, "report_uri")
  
  
  