# 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 copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'EdgeCacheKeysetPublicKeyArgs',
    'EdgeCacheKeysetValidationSharedKeyArgs',
    'EdgeCacheOriginAwsV4AuthenticationArgs',
    'EdgeCacheOriginOriginOverrideActionArgs',
    'EdgeCacheOriginOriginOverrideActionHeaderActionArgs',
    'EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs',
    'EdgeCacheOriginOriginOverrideActionUrlRewriteArgs',
    'EdgeCacheOriginOriginRedirectArgs',
    'EdgeCacheOriginTimeoutArgs',
    'EdgeCacheServiceLogConfigArgs',
    'EdgeCacheServiceRoutingArgs',
    'EdgeCacheServiceRoutingHostRuleArgs',
    'EdgeCacheServiceRoutingPathMatcherArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs',
    'EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs',
    'EndpointPolicyEndpointMatcherArgs',
    'EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs',
    'EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs',
    'EndpointPolicyTrafficPortSelectorArgs',
    'GrpcRouteRuleArgs',
    'GrpcRouteRuleActionArgs',
    'GrpcRouteRuleActionDestinationArgs',
    'GrpcRouteRuleActionFaultInjectionPolicyArgs',
    'GrpcRouteRuleActionFaultInjectionPolicyAbortArgs',
    'GrpcRouteRuleActionFaultInjectionPolicyDelayArgs',
    'GrpcRouteRuleActionRetryPolicyArgs',
    'GrpcRouteRuleMatchArgs',
    'GrpcRouteRuleMatchHeaderArgs',
    'GrpcRouteRuleMatchMethodArgs',
    'HttpRouteRuleArgs',
    'HttpRouteRuleActionArgs',
    'HttpRouteRuleActionCorsPolicyArgs',
    'HttpRouteRuleActionDestinationArgs',
    'HttpRouteRuleActionFaultInjectionPolicyArgs',
    'HttpRouteRuleActionFaultInjectionPolicyAbortArgs',
    'HttpRouteRuleActionFaultInjectionPolicyDelayArgs',
    'HttpRouteRuleActionRedirectArgs',
    'HttpRouteRuleActionRequestHeaderModifierArgs',
    'HttpRouteRuleActionRequestMirrorPolicyArgs',
    'HttpRouteRuleActionRequestMirrorPolicyDestinationArgs',
    'HttpRouteRuleActionResponseHeaderModifierArgs',
    'HttpRouteRuleActionRetryPolicyArgs',
    'HttpRouteRuleActionUrlRewriteArgs',
    'HttpRouteRuleMatchArgs',
    'HttpRouteRuleMatchHeaderArgs',
    'HttpRouteRuleMatchHeaderRangeMatchArgs',
    'HttpRouteRuleMatchQueryParameterArgs',
    'TcpRouteRuleArgs',
    'TcpRouteRuleActionArgs',
    'TcpRouteRuleActionDestinationArgs',
    'TcpRouteRuleMatchArgs',
    'TlsRouteRuleArgs',
    'TlsRouteRuleActionArgs',
    'TlsRouteRuleActionDestinationArgs',
    'TlsRouteRuleMatchArgs',
]

@pulumi.input_type
class EdgeCacheKeysetPublicKeyArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 managed: Optional[pulumi.Input[bool]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] id: The ID of the public key. The ID must be 1-63 characters long, and comply with RFC1035.
               The name must be 1-64 characters long, and match the regular expression [a-zA-Z][a-zA-Z0-9_-]*
               which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.
        :param pulumi.Input[bool] managed: Set to true to have the CDN automatically manage this public key value.
        :param pulumi.Input[str] value: The base64-encoded value of the Ed25519 public key. The base64 encoding can be padded (44 bytes) or unpadded (43 bytes).
               Representations or encodings of the public key other than this will be rejected with an error.
               **Note**: This property is sensitive and will not be displayed in the plan.
        """
        pulumi.set(__self__, "id", id)
        if managed is not None:
            pulumi.set(__self__, "managed", managed)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def id(self) -> pulumi.Input[str]:
        """
        The ID of the public key. The ID must be 1-63 characters long, and comply with RFC1035.
        The name must be 1-64 characters long, and match the regular expression [a-zA-Z][a-zA-Z0-9_-]*
        which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter
    def managed(self) -> Optional[pulumi.Input[bool]]:
        """
        Set to true to have the CDN automatically manage this public key value.
        """
        return pulumi.get(self, "managed")

    @managed.setter
    def managed(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "managed", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        The base64-encoded value of the Ed25519 public key. The base64 encoding can be padded (44 bytes) or unpadded (43 bytes).
        Representations or encodings of the public key other than this will be rejected with an error.
        **Note**: This property is sensitive and will not be displayed in the plan.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class EdgeCacheKeysetValidationSharedKeyArgs:
    def __init__(__self__, *,
                 secret_version: pulumi.Input[str]):
        """
        :param pulumi.Input[str] secret_version: The name of the secret version in Secret Manager.
               The resource name of the secret version must be in the format `projects/*/secrets/*/versions/*` where the `*` values are replaced by the secrets themselves.
               The secrets must be at least 16 bytes large.  The recommended secret size depends on the signature algorithm you are using.
               * If you are using HMAC-SHA1, we suggest 20-byte secrets.
               * If you are using HMAC-SHA256, we suggest 32-byte secrets.
               See RFC 2104, Section 3 for more details on these recommendations.
        """
        pulumi.set(__self__, "secret_version", secret_version)

    @property
    @pulumi.getter(name="secretVersion")
    def secret_version(self) -> pulumi.Input[str]:
        """
        The name of the secret version in Secret Manager.
        The resource name of the secret version must be in the format `projects/*/secrets/*/versions/*` where the `*` values are replaced by the secrets themselves.
        The secrets must be at least 16 bytes large.  The recommended secret size depends on the signature algorithm you are using.
        * If you are using HMAC-SHA1, we suggest 20-byte secrets.
        * If you are using HMAC-SHA256, we suggest 32-byte secrets.
        See RFC 2104, Section 3 for more details on these recommendations.
        """
        return pulumi.get(self, "secret_version")

    @secret_version.setter
    def secret_version(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_version", value)


@pulumi.input_type
class EdgeCacheOriginAwsV4AuthenticationArgs:
    def __init__(__self__, *,
                 access_key_id: pulumi.Input[str],
                 origin_region: pulumi.Input[str],
                 secret_access_key_version: pulumi.Input[str]):
        """
        :param pulumi.Input[str] access_key_id: The access key ID your origin uses to identify the key.
        :param pulumi.Input[str] origin_region: The name of the AWS region that your origin is in.
        :param pulumi.Input[str] secret_access_key_version: The Secret Manager secret version of the secret access key used by your origin.
               This is the resource name of the secret version in the format `projects/*/secrets/*/versions/*` where the `*` values are replaced by the project, secret, and version you require.
        """
        pulumi.set(__self__, "access_key_id", access_key_id)
        pulumi.set(__self__, "origin_region", origin_region)
        pulumi.set(__self__, "secret_access_key_version", secret_access_key_version)

    @property
    @pulumi.getter(name="accessKeyId")
    def access_key_id(self) -> pulumi.Input[str]:
        """
        The access key ID your origin uses to identify the key.
        """
        return pulumi.get(self, "access_key_id")

    @access_key_id.setter
    def access_key_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "access_key_id", value)

    @property
    @pulumi.getter(name="originRegion")
    def origin_region(self) -> pulumi.Input[str]:
        """
        The name of the AWS region that your origin is in.
        """
        return pulumi.get(self, "origin_region")

    @origin_region.setter
    def origin_region(self, value: pulumi.Input[str]):
        pulumi.set(self, "origin_region", value)

    @property
    @pulumi.getter(name="secretAccessKeyVersion")
    def secret_access_key_version(self) -> pulumi.Input[str]:
        """
        The Secret Manager secret version of the secret access key used by your origin.
        This is the resource name of the secret version in the format `projects/*/secrets/*/versions/*` where the `*` values are replaced by the project, secret, and version you require.
        """
        return pulumi.get(self, "secret_access_key_version")

    @secret_access_key_version.setter
    def secret_access_key_version(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_access_key_version", value)


@pulumi.input_type
class EdgeCacheOriginOriginOverrideActionArgs:
    def __init__(__self__, *,
                 header_action: Optional[pulumi.Input['EdgeCacheOriginOriginOverrideActionHeaderActionArgs']] = None,
                 url_rewrite: Optional[pulumi.Input['EdgeCacheOriginOriginOverrideActionUrlRewriteArgs']] = None):
        """
        :param pulumi.Input['EdgeCacheOriginOriginOverrideActionHeaderActionArgs'] header_action: The header actions, including adding and removing
               headers, for request handled by this origin.
               Structure is documented below.
        :param pulumi.Input['EdgeCacheOriginOriginOverrideActionUrlRewriteArgs'] url_rewrite: The URL rewrite configuration for request that are
               handled by this origin.
               Structure is documented below.
        """
        if header_action is not None:
            pulumi.set(__self__, "header_action", header_action)
        if url_rewrite is not None:
            pulumi.set(__self__, "url_rewrite", url_rewrite)

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional[pulumi.Input['EdgeCacheOriginOriginOverrideActionHeaderActionArgs']]:
        """
        The header actions, including adding and removing
        headers, for request handled by this origin.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @header_action.setter
    def header_action(self, value: Optional[pulumi.Input['EdgeCacheOriginOriginOverrideActionHeaderActionArgs']]):
        pulumi.set(self, "header_action", value)

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional[pulumi.Input['EdgeCacheOriginOriginOverrideActionUrlRewriteArgs']]:
        """
        The URL rewrite configuration for request that are
        handled by this origin.
        Structure is documented below.
        """
        return pulumi.get(self, "url_rewrite")

    @url_rewrite.setter
    def url_rewrite(self, value: Optional[pulumi.Input['EdgeCacheOriginOriginOverrideActionUrlRewriteArgs']]):
        pulumi.set(self, "url_rewrite", value)


@pulumi.input_type
class EdgeCacheOriginOriginOverrideActionHeaderActionArgs:
    def __init__(__self__, *,
                 request_headers_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs']]] request_headers_to_adds: Describes a header to add.
               You may add a maximum of 25 request headers.
               Structure is documented below.
        """
        if request_headers_to_adds is not None:
            pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)

    @property
    @pulumi.getter(name="requestHeadersToAdds")
    def request_headers_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs']]]]:
        """
        Describes a header to add.
        You may add a maximum of 25 request headers.
        Structure is documented below.
        """
        return pulumi.get(self, "request_headers_to_adds")

    @request_headers_to_adds.setter
    def request_headers_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs']]]]):
        pulumi.set(self, "request_headers_to_adds", value)


@pulumi.input_type
class EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: Whether to replace all existing headers with the same name.
               By default, added header values are appended
               to the response or request headers with the
               same field names. The added values are
               separated by commas.
               To overwrite existing values, set `replace` to `true`.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        if replace is not None:
            pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to replace all existing headers with the same name.
        By default, added header values are appended
        to the response or request headers with the
        same field names. The added values are
        separated by commas.
        To overwrite existing values, set `replace` to `true`.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class EdgeCacheOriginOriginOverrideActionUrlRewriteArgs:
    def __init__(__self__, *,
                 host_rewrite: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_rewrite: Prior to forwarding the request to the selected
               origin, the request's host header is replaced with
               contents of the hostRewrite.
               This value must be between 1 and 255 characters.
        """
        if host_rewrite is not None:
            pulumi.set(__self__, "host_rewrite", host_rewrite)

    @property
    @pulumi.getter(name="hostRewrite")
    def host_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected
        origin, the request's host header is replaced with
        contents of the hostRewrite.
        This value must be between 1 and 255 characters.
        """
        return pulumi.get(self, "host_rewrite")

    @host_rewrite.setter
    def host_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_rewrite", value)


@pulumi.input_type
class EdgeCacheOriginOriginRedirectArgs:
    def __init__(__self__, *,
                 redirect_conditions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] redirect_conditions: The set of redirect response codes that the CDN
               follows. Values of
               [RedirectConditions](https://cloud.google.com/media-cdn/docs/reference/rest/v1/projects.locations.edgeCacheOrigins#redirectconditions)
               are accepted.
        """
        if redirect_conditions is not None:
            pulumi.set(__self__, "redirect_conditions", redirect_conditions)

    @property
    @pulumi.getter(name="redirectConditions")
    def redirect_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The set of redirect response codes that the CDN
        follows. Values of
        [RedirectConditions](https://cloud.google.com/media-cdn/docs/reference/rest/v1/projects.locations.edgeCacheOrigins#redirectconditions)
        are accepted.
        """
        return pulumi.get(self, "redirect_conditions")

    @redirect_conditions.setter
    def redirect_conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "redirect_conditions", value)


@pulumi.input_type
class EdgeCacheOriginTimeoutArgs:
    def __init__(__self__, *,
                 connect_timeout: Optional[pulumi.Input[str]] = None,
                 max_attempts_timeout: Optional[pulumi.Input[str]] = None,
                 read_timeout: Optional[pulumi.Input[str]] = None,
                 response_timeout: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] connect_timeout: The maximum duration to wait for a single origin connection to be established, including DNS lookup, TLS handshake and TCP/QUIC connection establishment.
               Defaults to 5 seconds. The timeout must be a value between 1s and 15s.
               The connectTimeout capped by the deadline set by the request's maxAttemptsTimeout.  The last connection attempt may have a smaller connectTimeout in order to adhere to the overall maxAttemptsTimeout.
        :param pulumi.Input[str] max_attempts_timeout: The maximum time across all connection attempts to the origin, including failover origins, before returning an error to the client. A HTTP 504 will be returned if the timeout is reached before a response is returned.
               Defaults to 15 seconds. The timeout must be a value between 1s and 30s.
               If a failoverOrigin is specified, the maxAttemptsTimeout of the first configured origin sets the deadline for all connection attempts across all failoverOrigins.
        :param pulumi.Input[str] read_timeout: The maximum duration to wait between reads of a single HTTP connection/stream.
               Defaults to 15 seconds.  The timeout must be a value between 1s and 30s.
               The readTimeout is capped by the responseTimeout.  All reads of the HTTP connection/stream must be completed by the deadline set by the responseTimeout.
               If the response headers have already been written to the connection, the response will be truncated and logged.
               
               <a name="nested_aws_v4_authentication"></a>The `aws_v4_authentication` block supports:
        :param pulumi.Input[str] response_timeout: The maximum duration to wait for the last byte of a response to arrive when reading from the HTTP connection/stream.
               Defaults to 30 seconds. The timeout must be a value between 1s and 120s.
               The responseTimeout starts after the connection has been established.
               This also applies to HTTP Chunked Transfer Encoding responses, and/or when an open-ended Range request is made to the origin. Origins that take longer to write additional bytes to the response than the configured responseTimeout will result in an error being returned to the client.
               If the response headers have already been written to the connection, the response will be truncated and logged.
        """
        if connect_timeout is not None:
            pulumi.set(__self__, "connect_timeout", connect_timeout)
        if max_attempts_timeout is not None:
            pulumi.set(__self__, "max_attempts_timeout", max_attempts_timeout)
        if read_timeout is not None:
            pulumi.set(__self__, "read_timeout", read_timeout)
        if response_timeout is not None:
            pulumi.set(__self__, "response_timeout", response_timeout)

    @property
    @pulumi.getter(name="connectTimeout")
    def connect_timeout(self) -> Optional[pulumi.Input[str]]:
        """
        The maximum duration to wait for a single origin connection to be established, including DNS lookup, TLS handshake and TCP/QUIC connection establishment.
        Defaults to 5 seconds. The timeout must be a value between 1s and 15s.
        The connectTimeout capped by the deadline set by the request's maxAttemptsTimeout.  The last connection attempt may have a smaller connectTimeout in order to adhere to the overall maxAttemptsTimeout.
        """
        return pulumi.get(self, "connect_timeout")

    @connect_timeout.setter
    def connect_timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "connect_timeout", value)

    @property
    @pulumi.getter(name="maxAttemptsTimeout")
    def max_attempts_timeout(self) -> Optional[pulumi.Input[str]]:
        """
        The maximum time across all connection attempts to the origin, including failover origins, before returning an error to the client. A HTTP 504 will be returned if the timeout is reached before a response is returned.
        Defaults to 15 seconds. The timeout must be a value between 1s and 30s.
        If a failoverOrigin is specified, the maxAttemptsTimeout of the first configured origin sets the deadline for all connection attempts across all failoverOrigins.
        """
        return pulumi.get(self, "max_attempts_timeout")

    @max_attempts_timeout.setter
    def max_attempts_timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_attempts_timeout", value)

    @property
    @pulumi.getter(name="readTimeout")
    def read_timeout(self) -> Optional[pulumi.Input[str]]:
        """
        The maximum duration to wait between reads of a single HTTP connection/stream.
        Defaults to 15 seconds.  The timeout must be a value between 1s and 30s.
        The readTimeout is capped by the responseTimeout.  All reads of the HTTP connection/stream must be completed by the deadline set by the responseTimeout.
        If the response headers have already been written to the connection, the response will be truncated and logged.

        <a name="nested_aws_v4_authentication"></a>The `aws_v4_authentication` block supports:
        """
        return pulumi.get(self, "read_timeout")

    @read_timeout.setter
    def read_timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "read_timeout", value)

    @property
    @pulumi.getter(name="responseTimeout")
    def response_timeout(self) -> Optional[pulumi.Input[str]]:
        """
        The maximum duration to wait for the last byte of a response to arrive when reading from the HTTP connection/stream.
        Defaults to 30 seconds. The timeout must be a value between 1s and 120s.
        The responseTimeout starts after the connection has been established.
        This also applies to HTTP Chunked Transfer Encoding responses, and/or when an open-ended Range request is made to the origin. Origins that take longer to write additional bytes to the response than the configured responseTimeout will result in an error being returned to the client.
        If the response headers have already been written to the connection, the response will be truncated and logged.
        """
        return pulumi.get(self, "response_timeout")

    @response_timeout.setter
    def response_timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "response_timeout", value)


@pulumi.input_type
class EdgeCacheServiceLogConfigArgs:
    def __init__(__self__, *,
                 enable: Optional[pulumi.Input[bool]] = None,
                 sample_rate: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[bool] enable: Specifies whether to enable logging for traffic served by this service.
        :param pulumi.Input[float] sample_rate: Configures the sampling rate of requests, where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported. The default value is 1.0, and the value of the field must be in [0, 1].
               This field can only be specified if logging is enabled for this service.
        """
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if sample_rate is not None:
            pulumi.set(__self__, "sample_rate", sample_rate)

    @property
    @pulumi.getter
    def enable(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether to enable logging for traffic served by this service.
        """
        return pulumi.get(self, "enable")

    @enable.setter
    def enable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable", value)

    @property
    @pulumi.getter(name="sampleRate")
    def sample_rate(self) -> Optional[pulumi.Input[float]]:
        """
        Configures the sampling rate of requests, where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported. The default value is 1.0, and the value of the field must be in [0, 1].
        This field can only be specified if logging is enabled for this service.
        """
        return pulumi.get(self, "sample_rate")

    @sample_rate.setter
    def sample_rate(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "sample_rate", value)


@pulumi.input_type
class EdgeCacheServiceRoutingArgs:
    def __init__(__self__, *,
                 host_rules: pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingHostRuleArgs']]],
                 path_matchers: pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingHostRuleArgs']]] host_rules: The list of hostRules to match against. These rules define which hostnames the EdgeCacheService will match against, and which route configurations apply.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherArgs']]] path_matchers: The list of pathMatchers referenced via name by hostRules. PathMatcher is used to match the path portion of the URL when a HostRule matches the URL's host portion.
               Structure is documented below.
        """
        pulumi.set(__self__, "host_rules", host_rules)
        pulumi.set(__self__, "path_matchers", path_matchers)

    @property
    @pulumi.getter(name="hostRules")
    def host_rules(self) -> pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingHostRuleArgs']]]:
        """
        The list of hostRules to match against. These rules define which hostnames the EdgeCacheService will match against, and which route configurations apply.
        Structure is documented below.
        """
        return pulumi.get(self, "host_rules")

    @host_rules.setter
    def host_rules(self, value: pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingHostRuleArgs']]]):
        pulumi.set(self, "host_rules", value)

    @property
    @pulumi.getter(name="pathMatchers")
    def path_matchers(self) -> pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherArgs']]]:
        """
        The list of pathMatchers referenced via name by hostRules. PathMatcher is used to match the path portion of the URL when a HostRule matches the URL's host portion.
        Structure is documented below.
        """
        return pulumi.get(self, "path_matchers")

    @path_matchers.setter
    def path_matchers(self, value: pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherArgs']]]):
        pulumi.set(self, "path_matchers", value)


@pulumi.input_type
class EdgeCacheServiceRoutingHostRuleArgs:
    def __init__(__self__, *,
                 hosts: pulumi.Input[Sequence[pulumi.Input[str]]],
                 path_matcher: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] hosts: The list of host patterns to match.
               Host patterns must be valid hostnames. Ports are not allowed. Wildcard hosts are supported in the suffix or prefix form. * matches any string of ([a-z0-9-.]*). It does not match the empty string.
               When multiple hosts are specified, hosts are matched in the following priority:
               1. Exact domain names: ``www.foo.com``.
               2. Suffix domain wildcards: ``*.foo.com`` or ``*-bar.foo.com``.
               3. Prefix domain wildcards: ``foo.*`` or ``foo-*``.
               4. Special wildcard ``*`` matching any domain.
               Notes:
               The wildcard will not match the empty string. e.g. ``*-bar.foo.com`` will match ``baz-bar.foo.com`` but not ``-bar.foo.com``. The longest wildcards match first. Only a single host in the entire service can match on ``*``. A domain must be unique across all configured hosts within a service.
               Hosts are matched against the HTTP Host header, or for HTTP/2 and HTTP/3, the ":authority" header, from the incoming request.
               You may specify up to 10 hosts.
        :param pulumi.Input[str] path_matcher: The name of the pathMatcher associated with this hostRule.
        :param pulumi.Input[str] description: A human-readable description of the hostRule.
        """
        pulumi.set(__self__, "hosts", hosts)
        pulumi.set(__self__, "path_matcher", path_matcher)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def hosts(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The list of host patterns to match.
        Host patterns must be valid hostnames. Ports are not allowed. Wildcard hosts are supported in the suffix or prefix form. * matches any string of ([a-z0-9-.]*). It does not match the empty string.
        When multiple hosts are specified, hosts are matched in the following priority:
        1. Exact domain names: ``www.foo.com``.
        2. Suffix domain wildcards: ``*.foo.com`` or ``*-bar.foo.com``.
        3. Prefix domain wildcards: ``foo.*`` or ``foo-*``.
        4. Special wildcard ``*`` matching any domain.
        Notes:
        The wildcard will not match the empty string. e.g. ``*-bar.foo.com`` will match ``baz-bar.foo.com`` but not ``-bar.foo.com``. The longest wildcards match first. Only a single host in the entire service can match on ``*``. A domain must be unique across all configured hosts within a service.
        Hosts are matched against the HTTP Host header, or for HTTP/2 and HTTP/3, the ":authority" header, from the incoming request.
        You may specify up to 10 hosts.
        """
        return pulumi.get(self, "hosts")

    @hosts.setter
    def hosts(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "hosts", value)

    @property
    @pulumi.getter(name="pathMatcher")
    def path_matcher(self) -> pulumi.Input[str]:
        """
        The name of the pathMatcher associated with this hostRule.
        """
        return pulumi.get(self, "path_matcher")

    @path_matcher.setter
    def path_matcher(self, value: pulumi.Input[str]):
        pulumi.set(self, "path_matcher", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A human-readable description of the hostRule.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 route_rules: pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleArgs']]],
                 description: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name to which this PathMatcher is referred by the HostRule.
        :param pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleArgs']]] route_rules: The routeRules to match against. routeRules support advanced routing behaviour, and can match on paths, headers and query parameters, as well as status codes and HTTP methods.
               Structure is documented below.
        :param pulumi.Input[str] description: A human-readable description of the resource.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "route_rules", route_rules)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name to which this PathMatcher is referred by the HostRule.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="routeRules")
    def route_rules(self) -> pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleArgs']]]:
        """
        The routeRules to match against. routeRules support advanced routing behaviour, and can match on paths, headers and query parameters, as well as status codes and HTTP methods.
        Structure is documented below.
        """
        return pulumi.get(self, "route_rules")

    @route_rules.setter
    def route_rules(self, value: pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleArgs']]]):
        pulumi.set(self, "route_rules", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A human-readable description of the resource.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleArgs:
    def __init__(__self__, *,
                 match_rules: pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs']]],
                 priority: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None,
                 header_action: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs']] = None,
                 origin: Optional[pulumi.Input[str]] = None,
                 route_action: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs']] = None,
                 url_redirect: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs']]] match_rules: The list of criteria for matching attributes of a request to this routeRule. This list has OR semantics: the request matches this routeRule when any of the matchRules are satisfied. However predicates
               within a given matchRule have AND semantics. All predicates within a matchRule must match for the request to match the rule.
               Structure is documented below.
        :param pulumi.Input[str] priority: The priority of this route rule, where 1 is the highest priority.
               You cannot configure two or more routeRules with the same priority. Priority for each rule must be set to a number between 1 and 999 inclusive.
               Priority numbers can have gaps, which enable you to add or remove rules in the future without affecting the rest of the rules. For example, 1, 2, 3, 4, 5, 9, 12, 16 is a valid series of priority numbers
               to which you could add rules numbered from 6 to 8, 10 to 11, and 13 to 15 in the future without any impact on existing rules.
        :param pulumi.Input[str] description: A human-readable description of the routeRule.
        :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs'] header_action: The header actions, including adding & removing headers, for requests that match this route.
               Structure is documented below.
        :param pulumi.Input[str] origin: The Origin resource that requests to this route should fetch from when a matching response is not in cache. Origins can be defined as short names ("my-origin") or fully-qualified resource URLs - e.g. "networkservices.googleapis.com/projects/my-project/global/edgecacheorigins/my-origin"
               Only one of origin or urlRedirect can be set.
        :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs'] route_action: In response to a matching path, the routeAction performs advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request to the selected origin.
               Structure is documented below.
        :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs'] url_redirect: The URL redirect configuration for requests that match this route.
               Structure is documented below.
        """
        pulumi.set(__self__, "match_rules", match_rules)
        pulumi.set(__self__, "priority", priority)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if header_action is not None:
            pulumi.set(__self__, "header_action", header_action)
        if origin is not None:
            pulumi.set(__self__, "origin", origin)
        if route_action is not None:
            pulumi.set(__self__, "route_action", route_action)
        if url_redirect is not None:
            pulumi.set(__self__, "url_redirect", url_redirect)

    @property
    @pulumi.getter(name="matchRules")
    def match_rules(self) -> pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs']]]:
        """
        The list of criteria for matching attributes of a request to this routeRule. This list has OR semantics: the request matches this routeRule when any of the matchRules are satisfied. However predicates
        within a given matchRule have AND semantics. All predicates within a matchRule must match for the request to match the rule.
        Structure is documented below.
        """
        return pulumi.get(self, "match_rules")

    @match_rules.setter
    def match_rules(self, value: pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs']]]):
        pulumi.set(self, "match_rules", value)

    @property
    @pulumi.getter
    def priority(self) -> pulumi.Input[str]:
        """
        The priority of this route rule, where 1 is the highest priority.
        You cannot configure two or more routeRules with the same priority. Priority for each rule must be set to a number between 1 and 999 inclusive.
        Priority numbers can have gaps, which enable you to add or remove rules in the future without affecting the rest of the rules. For example, 1, 2, 3, 4, 5, 9, 12, 16 is a valid series of priority numbers
        to which you could add rules numbered from 6 to 8, 10 to 11, and 13 to 15 in the future without any impact on existing rules.
        """
        return pulumi.get(self, "priority")

    @priority.setter
    def priority(self, value: pulumi.Input[str]):
        pulumi.set(self, "priority", value)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        A human-readable description of the routeRule.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter(name="headerAction")
    def header_action(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs']]:
        """
        The header actions, including adding & removing headers, for requests that match this route.
        Structure is documented below.
        """
        return pulumi.get(self, "header_action")

    @header_action.setter
    def header_action(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs']]):
        pulumi.set(self, "header_action", value)

    @property
    @pulumi.getter
    def origin(self) -> Optional[pulumi.Input[str]]:
        """
        The Origin resource that requests to this route should fetch from when a matching response is not in cache. Origins can be defined as short names ("my-origin") or fully-qualified resource URLs - e.g. "networkservices.googleapis.com/projects/my-project/global/edgecacheorigins/my-origin"
        Only one of origin or urlRedirect can be set.
        """
        return pulumi.get(self, "origin")

    @origin.setter
    def origin(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "origin", value)

    @property
    @pulumi.getter(name="routeAction")
    def route_action(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs']]:
        """
        In response to a matching path, the routeAction performs advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request to the selected origin.
        Structure is documented below.
        """
        return pulumi.get(self, "route_action")

    @route_action.setter
    def route_action(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs']]):
        pulumi.set(self, "route_action", value)

    @property
    @pulumi.getter(name="urlRedirect")
    def url_redirect(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs']]:
        """
        The URL redirect configuration for requests that match this route.
        Structure is documented below.
        """
        return pulumi.get(self, "url_redirect")

    @url_redirect.setter
    def url_redirect(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs']]):
        pulumi.set(self, "url_redirect", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs:
    def __init__(__self__, *,
                 request_header_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs']]]] = None,
                 request_header_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs']]]] = None,
                 response_header_to_adds: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs']]]] = None,
                 response_header_to_removes: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs']]] request_header_to_adds: Describes a header to add.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs']]] request_header_to_removes: A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs']]] response_header_to_adds: Headers to add to the response prior to sending it back to the client.
               Response headers are only sent to the client, and do not have an effect on the cache serving the response.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs']]] response_header_to_removes: A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin.
               Structure is documented below.
        """
        if request_header_to_adds is not None:
            pulumi.set(__self__, "request_header_to_adds", request_header_to_adds)
        if request_header_to_removes is not None:
            pulumi.set(__self__, "request_header_to_removes", request_header_to_removes)
        if response_header_to_adds is not None:
            pulumi.set(__self__, "response_header_to_adds", response_header_to_adds)
        if response_header_to_removes is not None:
            pulumi.set(__self__, "response_header_to_removes", response_header_to_removes)

    @property
    @pulumi.getter(name="requestHeaderToAdds")
    def request_header_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs']]]]:
        """
        Describes a header to add.
        Structure is documented below.
        """
        return pulumi.get(self, "request_header_to_adds")

    @request_header_to_adds.setter
    def request_header_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs']]]]):
        pulumi.set(self, "request_header_to_adds", value)

    @property
    @pulumi.getter(name="requestHeaderToRemoves")
    def request_header_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs']]]]:
        """
        A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin.
        Structure is documented below.
        """
        return pulumi.get(self, "request_header_to_removes")

    @request_header_to_removes.setter
    def request_header_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs']]]]):
        pulumi.set(self, "request_header_to_removes", value)

    @property
    @pulumi.getter(name="responseHeaderToAdds")
    def response_header_to_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs']]]]:
        """
        Headers to add to the response prior to sending it back to the client.
        Response headers are only sent to the client, and do not have an effect on the cache serving the response.
        Structure is documented below.
        """
        return pulumi.get(self, "response_header_to_adds")

    @response_header_to_adds.setter
    def response_header_to_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs']]]]):
        pulumi.set(self, "response_header_to_adds", value)

    @property
    @pulumi.getter(name="responseHeaderToRemoves")
    def response_header_to_removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs']]]]:
        """
        A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin.
        Structure is documented below.
        """
        return pulumi.get(self, "response_header_to_removes")

    @response_header_to_removes.setter
    def response_header_to_removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs']]]]):
        pulumi.set(self, "response_header_to_removes", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: Whether to replace all existing headers with the same name.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        if replace is not None:
            pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to replace all existing headers with the same name.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] header_name: The name of the header to remove.
        """
        pulumi.set(__self__, "header_name", header_name)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to remove.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input[str],
                 replace: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] header_name: The name of the header to add.
        :param pulumi.Input[str] header_value: The value of the header to add.
        :param pulumi.Input[bool] replace: Whether to replace all existing headers with the same name.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)
        if replace is not None:
            pulumi.set(__self__, "replace", replace)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The name of the header to add.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input[str]:
        """
        The value of the header to add.
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_value", value)

    @property
    @pulumi.getter
    def replace(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to replace all existing headers with the same name.
        """
        return pulumi.get(self, "replace")

    @replace.setter
    def replace(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "replace", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] header_name: Headers to remove from the response prior to sending it back to the client.
               Response headers are only sent to the client, and do not have an effect on the cache serving the response.
        """
        pulumi.set(__self__, "header_name", header_name)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        Headers to remove from the response prior to sending it back to the client.
        Response headers are only sent to the client, and do not have an effect on the cache serving the response.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs:
    def __init__(__self__, *,
                 full_path_match: Optional[pulumi.Input[str]] = None,
                 header_matches: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs']]]] = None,
                 ignore_case: Optional[pulumi.Input[bool]] = None,
                 path_template_match: Optional[pulumi.Input[str]] = None,
                 prefix_match: Optional[pulumi.Input[str]] = None,
                 query_parameter_matches: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs']]]] = None):
        """
        :param pulumi.Input[str] full_path_match: For satisfying the matchRule condition, the path of the request must exactly match the value specified in fullPathMatch after removing any query parameters and anchor that may be part of the original URL.
        :param pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs']]] header_matches: Specifies a list of header match criteria, all of which must match corresponding headers in the request.
               Structure is documented below.
        :param pulumi.Input[bool] ignore_case: Specifies that prefixMatch and fullPathMatch matches are case sensitive.
        :param pulumi.Input[str] path_template_match: For satisfying the matchRule condition, the path of the request
               must match the wildcard pattern specified in pathTemplateMatch
               after removing any query parameters and anchor that may be part
               of the original URL.
               pathTemplateMatch must be between 1 and 255 characters
               (inclusive).  The pattern specified by pathTemplateMatch may
               have at most 5 wildcard operators and at most 5 variable
               captures in total.
        :param pulumi.Input[str] prefix_match: For satisfying the matchRule condition, the request's path must begin with the specified prefixMatch. prefixMatch must begin with a /.
        :param pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs']]] query_parameter_matches: Specifies a list of query parameter match criteria, all of which must match corresponding query parameters in the request.
               Structure is documented below.
        """
        if full_path_match is not None:
            pulumi.set(__self__, "full_path_match", full_path_match)
        if header_matches is not None:
            pulumi.set(__self__, "header_matches", header_matches)
        if ignore_case is not None:
            pulumi.set(__self__, "ignore_case", ignore_case)
        if path_template_match is not None:
            pulumi.set(__self__, "path_template_match", path_template_match)
        if prefix_match is not None:
            pulumi.set(__self__, "prefix_match", prefix_match)
        if query_parameter_matches is not None:
            pulumi.set(__self__, "query_parameter_matches", query_parameter_matches)

    @property
    @pulumi.getter(name="fullPathMatch")
    def full_path_match(self) -> Optional[pulumi.Input[str]]:
        """
        For satisfying the matchRule condition, the path of the request must exactly match the value specified in fullPathMatch after removing any query parameters and anchor that may be part of the original URL.
        """
        return pulumi.get(self, "full_path_match")

    @full_path_match.setter
    def full_path_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "full_path_match", value)

    @property
    @pulumi.getter(name="headerMatches")
    def header_matches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs']]]]:
        """
        Specifies a list of header match criteria, all of which must match corresponding headers in the request.
        Structure is documented below.
        """
        return pulumi.get(self, "header_matches")

    @header_matches.setter
    def header_matches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs']]]]):
        pulumi.set(self, "header_matches", value)

    @property
    @pulumi.getter(name="ignoreCase")
    def ignore_case(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies that prefixMatch and fullPathMatch matches are case sensitive.
        """
        return pulumi.get(self, "ignore_case")

    @ignore_case.setter
    def ignore_case(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_case", value)

    @property
    @pulumi.getter(name="pathTemplateMatch")
    def path_template_match(self) -> Optional[pulumi.Input[str]]:
        """
        For satisfying the matchRule condition, the path of the request
        must match the wildcard pattern specified in pathTemplateMatch
        after removing any query parameters and anchor that may be part
        of the original URL.
        pathTemplateMatch must be between 1 and 255 characters
        (inclusive).  The pattern specified by pathTemplateMatch may
        have at most 5 wildcard operators and at most 5 variable
        captures in total.
        """
        return pulumi.get(self, "path_template_match")

    @path_template_match.setter
    def path_template_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_template_match", value)

    @property
    @pulumi.getter(name="prefixMatch")
    def prefix_match(self) -> Optional[pulumi.Input[str]]:
        """
        For satisfying the matchRule condition, the request's path must begin with the specified prefixMatch. prefixMatch must begin with a /.
        """
        return pulumi.get(self, "prefix_match")

    @prefix_match.setter
    def prefix_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_match", value)

    @property
    @pulumi.getter(name="queryParameterMatches")
    def query_parameter_matches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs']]]]:
        """
        Specifies a list of query parameter match criteria, all of which must match corresponding query parameters in the request.
        Structure is documented below.
        """
        return pulumi.get(self, "query_parameter_matches")

    @query_parameter_matches.setter
    def query_parameter_matches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs']]]]):
        pulumi.set(self, "query_parameter_matches", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 exact_match: Optional[pulumi.Input[str]] = None,
                 invert_match: Optional[pulumi.Input[bool]] = None,
                 prefix_match: Optional[pulumi.Input[str]] = None,
                 present_match: Optional[pulumi.Input[bool]] = None,
                 suffix_match: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] header_name: The header name to match on.
        :param pulumi.Input[str] exact_match: The value of the header should exactly match contents of exactMatch.
        :param pulumi.Input[bool] invert_match: If set to false (default), the headerMatch is considered a match if the match criteria above are met.
               If set to true, the headerMatch is considered a match if the match criteria above are NOT met.
        :param pulumi.Input[str] prefix_match: The value of the header must start with the contents of prefixMatch.
        :param pulumi.Input[bool] present_match: A header with the contents of headerName must exist. The match takes place whether or not the request's header has a value.
        :param pulumi.Input[str] suffix_match: The value of the header must end with the contents of suffixMatch.
        """
        pulumi.set(__self__, "header_name", header_name)
        if exact_match is not None:
            pulumi.set(__self__, "exact_match", exact_match)
        if invert_match is not None:
            pulumi.set(__self__, "invert_match", invert_match)
        if prefix_match is not None:
            pulumi.set(__self__, "prefix_match", prefix_match)
        if present_match is not None:
            pulumi.set(__self__, "present_match", present_match)
        if suffix_match is not None:
            pulumi.set(__self__, "suffix_match", suffix_match)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[str]:
        """
        The header name to match on.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="exactMatch")
    def exact_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header should exactly match contents of exactMatch.
        """
        return pulumi.get(self, "exact_match")

    @exact_match.setter
    def exact_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "exact_match", value)

    @property
    @pulumi.getter(name="invertMatch")
    def invert_match(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to false (default), the headerMatch is considered a match if the match criteria above are met.
        If set to true, the headerMatch is considered a match if the match criteria above are NOT met.
        """
        return pulumi.get(self, "invert_match")

    @invert_match.setter
    def invert_match(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "invert_match", value)

    @property
    @pulumi.getter(name="prefixMatch")
    def prefix_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header must start with the contents of prefixMatch.
        """
        return pulumi.get(self, "prefix_match")

    @prefix_match.setter
    def prefix_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_match", value)

    @property
    @pulumi.getter(name="presentMatch")
    def present_match(self) -> Optional[pulumi.Input[bool]]:
        """
        A header with the contents of headerName must exist. The match takes place whether or not the request's header has a value.
        """
        return pulumi.get(self, "present_match")

    @present_match.setter
    def present_match(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "present_match", value)

    @property
    @pulumi.getter(name="suffixMatch")
    def suffix_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header must end with the contents of suffixMatch.
        """
        return pulumi.get(self, "suffix_match")

    @suffix_match.setter
    def suffix_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "suffix_match", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 exact_match: Optional[pulumi.Input[str]] = None,
                 present_match: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] name: The name of the query parameter to match. The query parameter must exist in the request, in the absence of which the request match fails.
        :param pulumi.Input[str] exact_match: The queryParameterMatch matches if the value of the parameter exactly matches the contents of exactMatch.
        :param pulumi.Input[bool] present_match: Specifies that the queryParameterMatch matches if the request contains the query parameter, irrespective of whether the parameter has a value or not.
        """
        pulumi.set(__self__, "name", name)
        if exact_match is not None:
            pulumi.set(__self__, "exact_match", exact_match)
        if present_match is not None:
            pulumi.set(__self__, "present_match", present_match)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the query parameter to match. The query parameter must exist in the request, in the absence of which the request match fails.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="exactMatch")
    def exact_match(self) -> Optional[pulumi.Input[str]]:
        """
        The queryParameterMatch matches if the value of the parameter exactly matches the contents of exactMatch.
        """
        return pulumi.get(self, "exact_match")

    @exact_match.setter
    def exact_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "exact_match", value)

    @property
    @pulumi.getter(name="presentMatch")
    def present_match(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies that the queryParameterMatch matches if the request contains the query parameter, irrespective of whether the parameter has a value or not.
        """
        return pulumi.get(self, "present_match")

    @present_match.setter
    def present_match(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "present_match", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs:
    def __init__(__self__, *,
                 cdn_policy: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs']] = None,
                 cors_policy: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs']] = None,
                 url_rewrite: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs']] = None):
        """
        :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs'] cdn_policy: The policy to use for defining caching and signed request behaviour for requests that match this route.
               Structure is documented below.
        :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs'] cors_policy: CORSPolicy defines Cross-Origin-Resource-Sharing configuration, including which CORS response headers will be set.
               Structure is documented below.
        :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs'] url_rewrite: The URL rewrite configuration for requests that match this route.
               Structure is documented below.
        """
        if cdn_policy is not None:
            pulumi.set(__self__, "cdn_policy", cdn_policy)
        if cors_policy is not None:
            pulumi.set(__self__, "cors_policy", cors_policy)
        if url_rewrite is not None:
            pulumi.set(__self__, "url_rewrite", url_rewrite)

    @property
    @pulumi.getter(name="cdnPolicy")
    def cdn_policy(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs']]:
        """
        The policy to use for defining caching and signed request behaviour for requests that match this route.
        Structure is documented below.
        """
        return pulumi.get(self, "cdn_policy")

    @cdn_policy.setter
    def cdn_policy(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs']]):
        pulumi.set(self, "cdn_policy", value)

    @property
    @pulumi.getter(name="corsPolicy")
    def cors_policy(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs']]:
        """
        CORSPolicy defines Cross-Origin-Resource-Sharing configuration, including which CORS response headers will be set.
        Structure is documented below.
        """
        return pulumi.get(self, "cors_policy")

    @cors_policy.setter
    def cors_policy(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs']]):
        pulumi.set(self, "cors_policy", value)

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs']]:
        """
        The URL rewrite configuration for requests that match this route.
        Structure is documented below.
        """
        return pulumi.get(self, "url_rewrite")

    @url_rewrite.setter
    def url_rewrite(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs']]):
        pulumi.set(self, "url_rewrite", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs:
    def __init__(__self__, *,
                 add_signatures: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs']] = None,
                 cache_key_policy: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs']] = None,
                 cache_mode: Optional[pulumi.Input[str]] = None,
                 client_ttl: Optional[pulumi.Input[str]] = None,
                 default_ttl: Optional[pulumi.Input[str]] = None,
                 max_ttl: Optional[pulumi.Input[str]] = None,
                 negative_caching: Optional[pulumi.Input[bool]] = None,
                 negative_caching_policy: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 signed_request_keyset: Optional[pulumi.Input[str]] = None,
                 signed_request_maximum_expiration_ttl: Optional[pulumi.Input[str]] = None,
                 signed_request_mode: Optional[pulumi.Input[str]] = None,
                 signed_token_options: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs']] = None):
        """
        :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs'] add_signatures: Enable signature generation or propagation on this route.
               This field may only be specified when signedRequestMode is set to REQUIRE_TOKENS.
               Structure is documented below.
        :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs'] cache_key_policy: Defines the request parameters that contribute to the cache key.
               Structure is documented below.
        :param pulumi.Input[str] cache_mode: Cache modes allow users to control the behaviour of the cache, what content it should cache automatically, whether to respect origin headers, or whether to unconditionally cache all responses.
               For all cache modes, Cache-Control headers will be passed to the client. Use clientTtl to override what is sent to the client.
               Possible values are: `CACHE_ALL_STATIC`, `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, `BYPASS_CACHE`.
        :param pulumi.Input[str] client_ttl: Specifies a separate client (e.g. browser client) TTL, separate from the TTL used by the edge caches. Leaving this empty will use the same cache TTL for both the CDN and the client-facing response.
               - The TTL must be > 0 and <= 86400s (1 day)
               - The clientTtl cannot be larger than the defaultTtl (if set)
               - Fractions of a second are not allowed.
               Omit this field to use the defaultTtl, or the max-age set by the origin, as the client-facing TTL.
               When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field.
               A duration in seconds terminated by 's'. Example: "3s".
        :param pulumi.Input[str] default_ttl: Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age).
               Defaults to 3600s (1 hour).
               - The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
               - Setting a TTL of "0" means "always revalidate" (equivalent to must-revalidate)
               - The value of defaultTTL cannot be set to a value greater than that of maxTTL.
               - Fractions of a second are not allowed.
               - When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses.
               Note that infrequently accessed objects may be evicted from the cache before the defined TTL. Objects that expire will be revalidated with the origin.
               When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field.
               A duration in seconds terminated by 's'. Example: "3s".
        :param pulumi.Input[str] max_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
               Defaults to 86400s (1 day).
               Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTtl seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive.
               - The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
               - Setting a TTL of "0" means "always revalidate"
               - The value of maxTtl must be equal to or greater than defaultTtl.
               - Fractions of a second are not allowed.
               When the cache mode is set to "USE_ORIGIN_HEADERS", "FORCE_CACHE_ALL", or "BYPASS_CACHE", you must omit this field.
               A duration in seconds terminated by 's'. Example: "3s".
        :param pulumi.Input[bool] negative_caching: Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency.
               By default, the CDNPolicy will apply the following default TTLs to these status codes:
               - HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m
               - HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s
               - HTTP 405 (Method Not Found), 414 (URI Too Long), 501 (Not Implemented): 60s
               These defaults can be overridden in negativeCachingPolicy
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] negative_caching_policy: Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
               - Omitting the policy and leaving negativeCaching enabled will use the default TTLs for each status code, defined in negativeCaching.
               - TTLs must be >= 0 (where 0 is "always revalidate") and <= 86400s (1 day)
               Note that when specifying an explicit negativeCachingPolicy, you should take care to specify a cache TTL for all response codes that you wish to cache. The CDNPolicy will not apply any default negative caching when a policy exists.
        :param pulumi.Input[str] signed_request_keyset: The EdgeCacheKeyset containing the set of public keys used to validate signed requests at the edge.
        :param pulumi.Input[str] signed_request_maximum_expiration_ttl: Limit how far into the future the expiration time of a signed request may be.
               When set, a signed request is rejected if its expiration time is later than now + signedRequestMaximumExpirationTtl, where now is the time at which the signed request is first handled by the CDN.
               - The TTL must be > 0.
               - Fractions of a second are not allowed.
               By default, signedRequestMaximumExpirationTtl is not set and the expiration time of a signed request may be arbitrarily far into future.
        :param pulumi.Input[str] signed_request_mode: Whether to enforce signed requests. The default value is DISABLED, which means all content is public, and does not authorize access.
               You must also set a signedRequestKeyset to enable signed requests.
               When set to REQUIRE_SIGNATURES, all matching requests will have their signature validated. Requests that were not signed with the corresponding private key, or that are otherwise invalid (expired, do not match the signature, IP address, or header) will be rejected with a HTTP 403 and (if enabled) logged.
               Possible values are: `DISABLED`, `REQUIRE_SIGNATURES`, `REQUIRE_TOKENS`.
        :param pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs'] signed_token_options: Additional options for signed tokens.
               signedTokenOptions may only be specified when signedRequestMode is REQUIRE_TOKENS.
               Structure is documented below.
        """
        if add_signatures is not None:
            pulumi.set(__self__, "add_signatures", add_signatures)
        if cache_key_policy is not None:
            pulumi.set(__self__, "cache_key_policy", cache_key_policy)
        if cache_mode is not None:
            pulumi.set(__self__, "cache_mode", cache_mode)
        if client_ttl is not None:
            pulumi.set(__self__, "client_ttl", client_ttl)
        if default_ttl is not None:
            pulumi.set(__self__, "default_ttl", default_ttl)
        if max_ttl is not None:
            pulumi.set(__self__, "max_ttl", max_ttl)
        if negative_caching is not None:
            pulumi.set(__self__, "negative_caching", negative_caching)
        if negative_caching_policy is not None:
            pulumi.set(__self__, "negative_caching_policy", negative_caching_policy)
        if signed_request_keyset is not None:
            pulumi.set(__self__, "signed_request_keyset", signed_request_keyset)
        if signed_request_maximum_expiration_ttl is not None:
            pulumi.set(__self__, "signed_request_maximum_expiration_ttl", signed_request_maximum_expiration_ttl)
        if signed_request_mode is not None:
            pulumi.set(__self__, "signed_request_mode", signed_request_mode)
        if signed_token_options is not None:
            pulumi.set(__self__, "signed_token_options", signed_token_options)

    @property
    @pulumi.getter(name="addSignatures")
    def add_signatures(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs']]:
        """
        Enable signature generation or propagation on this route.
        This field may only be specified when signedRequestMode is set to REQUIRE_TOKENS.
        Structure is documented below.
        """
        return pulumi.get(self, "add_signatures")

    @add_signatures.setter
    def add_signatures(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs']]):
        pulumi.set(self, "add_signatures", value)

    @property
    @pulumi.getter(name="cacheKeyPolicy")
    def cache_key_policy(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs']]:
        """
        Defines the request parameters that contribute to the cache key.
        Structure is documented below.
        """
        return pulumi.get(self, "cache_key_policy")

    @cache_key_policy.setter
    def cache_key_policy(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs']]):
        pulumi.set(self, "cache_key_policy", value)

    @property
    @pulumi.getter(name="cacheMode")
    def cache_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Cache modes allow users to control the behaviour of the cache, what content it should cache automatically, whether to respect origin headers, or whether to unconditionally cache all responses.
        For all cache modes, Cache-Control headers will be passed to the client. Use clientTtl to override what is sent to the client.
        Possible values are: `CACHE_ALL_STATIC`, `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, `BYPASS_CACHE`.
        """
        return pulumi.get(self, "cache_mode")

    @cache_mode.setter
    def cache_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cache_mode", value)

    @property
    @pulumi.getter(name="clientTtl")
    def client_ttl(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies a separate client (e.g. browser client) TTL, separate from the TTL used by the edge caches. Leaving this empty will use the same cache TTL for both the CDN and the client-facing response.
        - The TTL must be > 0 and <= 86400s (1 day)
        - The clientTtl cannot be larger than the defaultTtl (if set)
        - Fractions of a second are not allowed.
        Omit this field to use the defaultTtl, or the max-age set by the origin, as the client-facing TTL.
        When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field.
        A duration in seconds terminated by 's'. Example: "3s".
        """
        return pulumi.get(self, "client_ttl")

    @client_ttl.setter
    def client_ttl(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_ttl", value)

    @property
    @pulumi.getter(name="defaultTtl")
    def default_ttl(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age).
        Defaults to 3600s (1 hour).
        - The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
        - Setting a TTL of "0" means "always revalidate" (equivalent to must-revalidate)
        - The value of defaultTTL cannot be set to a value greater than that of maxTTL.
        - Fractions of a second are not allowed.
        - When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses.
        Note that infrequently accessed objects may be evicted from the cache before the defined TTL. Objects that expire will be revalidated with the origin.
        When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field.
        A duration in seconds terminated by 's'. Example: "3s".
        """
        return pulumi.get(self, "default_ttl")

    @default_ttl.setter
    def default_ttl(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_ttl", value)

    @property
    @pulumi.getter(name="maxTtl")
    def max_ttl(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the maximum allowed TTL for cached content served by this origin.
        Defaults to 86400s (1 day).
        Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTtl seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive.
        - The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
        - Setting a TTL of "0" means "always revalidate"
        - The value of maxTtl must be equal to or greater than defaultTtl.
        - Fractions of a second are not allowed.
        When the cache mode is set to "USE_ORIGIN_HEADERS", "FORCE_CACHE_ALL", or "BYPASS_CACHE", you must omit this field.
        A duration in seconds terminated by 's'. Example: "3s".
        """
        return pulumi.get(self, "max_ttl")

    @max_ttl.setter
    def max_ttl(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_ttl", value)

    @property
    @pulumi.getter(name="negativeCaching")
    def negative_caching(self) -> Optional[pulumi.Input[bool]]:
        """
        Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency.
        By default, the CDNPolicy will apply the following default TTLs to these status codes:
        - HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m
        - HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s
        - HTTP 405 (Method Not Found), 414 (URI Too Long), 501 (Not Implemented): 60s
        These defaults can be overridden in negativeCachingPolicy
        """
        return pulumi.get(self, "negative_caching")

    @negative_caching.setter
    def negative_caching(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "negative_caching", value)

    @property
    @pulumi.getter(name="negativeCachingPolicy")
    def negative_caching_policy(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
        - Omitting the policy and leaving negativeCaching enabled will use the default TTLs for each status code, defined in negativeCaching.
        - TTLs must be >= 0 (where 0 is "always revalidate") and <= 86400s (1 day)
        Note that when specifying an explicit negativeCachingPolicy, you should take care to specify a cache TTL for all response codes that you wish to cache. The CDNPolicy will not apply any default negative caching when a policy exists.
        """
        return pulumi.get(self, "negative_caching_policy")

    @negative_caching_policy.setter
    def negative_caching_policy(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "negative_caching_policy", value)

    @property
    @pulumi.getter(name="signedRequestKeyset")
    def signed_request_keyset(self) -> Optional[pulumi.Input[str]]:
        """
        The EdgeCacheKeyset containing the set of public keys used to validate signed requests at the edge.
        """
        return pulumi.get(self, "signed_request_keyset")

    @signed_request_keyset.setter
    def signed_request_keyset(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "signed_request_keyset", value)

    @property
    @pulumi.getter(name="signedRequestMaximumExpirationTtl")
    def signed_request_maximum_expiration_ttl(self) -> Optional[pulumi.Input[str]]:
        """
        Limit how far into the future the expiration time of a signed request may be.
        When set, a signed request is rejected if its expiration time is later than now + signedRequestMaximumExpirationTtl, where now is the time at which the signed request is first handled by the CDN.
        - The TTL must be > 0.
        - Fractions of a second are not allowed.
        By default, signedRequestMaximumExpirationTtl is not set and the expiration time of a signed request may be arbitrarily far into future.
        """
        return pulumi.get(self, "signed_request_maximum_expiration_ttl")

    @signed_request_maximum_expiration_ttl.setter
    def signed_request_maximum_expiration_ttl(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "signed_request_maximum_expiration_ttl", value)

    @property
    @pulumi.getter(name="signedRequestMode")
    def signed_request_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Whether to enforce signed requests. The default value is DISABLED, which means all content is public, and does not authorize access.
        You must also set a signedRequestKeyset to enable signed requests.
        When set to REQUIRE_SIGNATURES, all matching requests will have their signature validated. Requests that were not signed with the corresponding private key, or that are otherwise invalid (expired, do not match the signature, IP address, or header) will be rejected with a HTTP 403 and (if enabled) logged.
        Possible values are: `DISABLED`, `REQUIRE_SIGNATURES`, `REQUIRE_TOKENS`.
        """
        return pulumi.get(self, "signed_request_mode")

    @signed_request_mode.setter
    def signed_request_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "signed_request_mode", value)

    @property
    @pulumi.getter(name="signedTokenOptions")
    def signed_token_options(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs']]:
        """
        Additional options for signed tokens.
        signedTokenOptions may only be specified when signedRequestMode is REQUIRE_TOKENS.
        Structure is documented below.
        """
        return pulumi.get(self, "signed_token_options")

    @signed_token_options.setter
    def signed_token_options(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs']]):
        pulumi.set(self, "signed_token_options", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs:
    def __init__(__self__, *,
                 actions: pulumi.Input[str],
                 copied_parameters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 keyset: Optional[pulumi.Input[str]] = None,
                 token_query_parameter: Optional[pulumi.Input[str]] = None,
                 token_ttl: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] actions: The actions to take to add signatures to responses.
               Each value may be one of: `GENERATE_COOKIE`, `GENERATE_TOKEN_HLS_COOKIELESS`, `PROPAGATE_TOKEN_HLS_COOKIELESS`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] copied_parameters: The parameters to copy from the verified token to the generated token.
               Only the following parameters may be copied:
        :param pulumi.Input[str] keyset: The keyset to use for signature generation.
               The following are both valid paths to an EdgeCacheKeyset resource:
               * `projects/project/locations/global/edgeCacheKeysets/yourKeyset`
        :param pulumi.Input[str] token_query_parameter: The query parameter in which to put the generated token.
               If not specified, defaults to `edge-cache-token`.
               If specified, the name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.
               This field may only be set when the GENERATE_TOKEN_HLS_COOKIELESS or PROPAGATE_TOKEN_HLS_COOKIELESS actions are specified.
        :param pulumi.Input[str] token_ttl: The duration the token is valid starting from the moment the token is first generated.
               Defaults to `86400s` (1 day).
               The TTL must be >= 0 and <= 604,800 seconds (1 week).
               This field may only be specified when the GENERATE_COOKIE or GENERATE_TOKEN_HLS_COOKIELESS actions are specified.
               A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
        """
        pulumi.set(__self__, "actions", actions)
        if copied_parameters is not None:
            pulumi.set(__self__, "copied_parameters", copied_parameters)
        if keyset is not None:
            pulumi.set(__self__, "keyset", keyset)
        if token_query_parameter is not None:
            pulumi.set(__self__, "token_query_parameter", token_query_parameter)
        if token_ttl is not None:
            pulumi.set(__self__, "token_ttl", token_ttl)

    @property
    @pulumi.getter
    def actions(self) -> pulumi.Input[str]:
        """
        The actions to take to add signatures to responses.
        Each value may be one of: `GENERATE_COOKIE`, `GENERATE_TOKEN_HLS_COOKIELESS`, `PROPAGATE_TOKEN_HLS_COOKIELESS`.
        """
        return pulumi.get(self, "actions")

    @actions.setter
    def actions(self, value: pulumi.Input[str]):
        pulumi.set(self, "actions", value)

    @property
    @pulumi.getter(name="copiedParameters")
    def copied_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The parameters to copy from the verified token to the generated token.
        Only the following parameters may be copied:
        """
        return pulumi.get(self, "copied_parameters")

    @copied_parameters.setter
    def copied_parameters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "copied_parameters", value)

    @property
    @pulumi.getter
    def keyset(self) -> Optional[pulumi.Input[str]]:
        """
        The keyset to use for signature generation.
        The following are both valid paths to an EdgeCacheKeyset resource:
        * `projects/project/locations/global/edgeCacheKeysets/yourKeyset`
        """
        return pulumi.get(self, "keyset")

    @keyset.setter
    def keyset(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "keyset", value)

    @property
    @pulumi.getter(name="tokenQueryParameter")
    def token_query_parameter(self) -> Optional[pulumi.Input[str]]:
        """
        The query parameter in which to put the generated token.
        If not specified, defaults to `edge-cache-token`.
        If specified, the name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.
        This field may only be set when the GENERATE_TOKEN_HLS_COOKIELESS or PROPAGATE_TOKEN_HLS_COOKIELESS actions are specified.
        """
        return pulumi.get(self, "token_query_parameter")

    @token_query_parameter.setter
    def token_query_parameter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "token_query_parameter", value)

    @property
    @pulumi.getter(name="tokenTtl")
    def token_ttl(self) -> Optional[pulumi.Input[str]]:
        """
        The duration the token is valid starting from the moment the token is first generated.
        Defaults to `86400s` (1 day).
        The TTL must be >= 0 and <= 604,800 seconds (1 week).
        This field may only be specified when the GENERATE_COOKIE or GENERATE_TOKEN_HLS_COOKIELESS actions are specified.
        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
        """
        return pulumi.get(self, "token_ttl")

    @token_ttl.setter
    def token_ttl(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "token_ttl", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs:
    def __init__(__self__, *,
                 exclude_host: Optional[pulumi.Input[bool]] = None,
                 exclude_query_string: Optional[pulumi.Input[bool]] = None,
                 excluded_query_parameters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 include_protocol: Optional[pulumi.Input[bool]] = None,
                 included_cookie_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 included_header_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 included_query_parameters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[bool] exclude_host: If true, requests to different hosts will be cached separately.
               Note: this should only be enabled if hosts share the same origin and content. Removing the host from the cache key may inadvertently result in different objects being cached than intended, depending on which route the first user matched.
        :param pulumi.Input[bool] exclude_query_string: If true, exclude query string parameters from the cache key
               If false (the default), include the query string parameters in
               the cache key according to includeQueryParameters and
               excludeQueryParameters. If neither includeQueryParameters nor
               excludeQueryParameters is set, the entire query string will be
               included.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] excluded_query_parameters: Names of query string parameters to exclude from cache keys. All other parameters will be included.
               Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.
        :param pulumi.Input[bool] include_protocol: If true, http and https requests will be cached separately.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] included_cookie_names: Names of Cookies to include in cache keys.  The cookie name and cookie value of each cookie named will be used as part of the cache key.
               Cookie names:
               - must be valid RFC 6265 "cookie-name" tokens
               - are case sensitive
               - cannot start with "Edge-Cache-" (case insensitive)
               Note that specifying several cookies, and/or cookies that have a large range of values (e.g., per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance.
               You may specify up to three cookie names.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] included_header_names: Names of HTTP request headers to include in cache keys. The value of the header field will be used as part of the cache key.
               - Header names must be valid HTTP RFC 7230 header field values.
               - Header field names are case insensitive
               - To include the HTTP method, use ":method"
               Note that specifying several headers, and/or headers that have a large range of values (e.g. per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] included_query_parameters: Names of query string parameters to include in cache keys. All other parameters will be excluded.
               Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.
        """
        if exclude_host is not None:
            pulumi.set(__self__, "exclude_host", exclude_host)
        if exclude_query_string is not None:
            pulumi.set(__self__, "exclude_query_string", exclude_query_string)
        if excluded_query_parameters is not None:
            pulumi.set(__self__, "excluded_query_parameters", excluded_query_parameters)
        if include_protocol is not None:
            pulumi.set(__self__, "include_protocol", include_protocol)
        if included_cookie_names is not None:
            pulumi.set(__self__, "included_cookie_names", included_cookie_names)
        if included_header_names is not None:
            pulumi.set(__self__, "included_header_names", included_header_names)
        if included_query_parameters is not None:
            pulumi.set(__self__, "included_query_parameters", included_query_parameters)

    @property
    @pulumi.getter(name="excludeHost")
    def exclude_host(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, requests to different hosts will be cached separately.
        Note: this should only be enabled if hosts share the same origin and content. Removing the host from the cache key may inadvertently result in different objects being cached than intended, depending on which route the first user matched.
        """
        return pulumi.get(self, "exclude_host")

    @exclude_host.setter
    def exclude_host(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "exclude_host", value)

    @property
    @pulumi.getter(name="excludeQueryString")
    def exclude_query_string(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, exclude query string parameters from the cache key
        If false (the default), include the query string parameters in
        the cache key according to includeQueryParameters and
        excludeQueryParameters. If neither includeQueryParameters nor
        excludeQueryParameters is set, the entire query string will be
        included.
        """
        return pulumi.get(self, "exclude_query_string")

    @exclude_query_string.setter
    def exclude_query_string(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "exclude_query_string", value)

    @property
    @pulumi.getter(name="excludedQueryParameters")
    def excluded_query_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Names of query string parameters to exclude from cache keys. All other parameters will be included.
        Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.
        """
        return pulumi.get(self, "excluded_query_parameters")

    @excluded_query_parameters.setter
    def excluded_query_parameters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "excluded_query_parameters", value)

    @property
    @pulumi.getter(name="includeProtocol")
    def include_protocol(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, http and https requests will be cached separately.
        """
        return pulumi.get(self, "include_protocol")

    @include_protocol.setter
    def include_protocol(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "include_protocol", value)

    @property
    @pulumi.getter(name="includedCookieNames")
    def included_cookie_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Names of Cookies to include in cache keys.  The cookie name and cookie value of each cookie named will be used as part of the cache key.
        Cookie names:
        - must be valid RFC 6265 "cookie-name" tokens
        - are case sensitive
        - cannot start with "Edge-Cache-" (case insensitive)
        Note that specifying several cookies, and/or cookies that have a large range of values (e.g., per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance.
        You may specify up to three cookie names.
        """
        return pulumi.get(self, "included_cookie_names")

    @included_cookie_names.setter
    def included_cookie_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "included_cookie_names", value)

    @property
    @pulumi.getter(name="includedHeaderNames")
    def included_header_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Names of HTTP request headers to include in cache keys. The value of the header field will be used as part of the cache key.
        - Header names must be valid HTTP RFC 7230 header field values.
        - Header field names are case insensitive
        - To include the HTTP method, use ":method"
        Note that specifying several headers, and/or headers that have a large range of values (e.g. per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance.
        """
        return pulumi.get(self, "included_header_names")

    @included_header_names.setter
    def included_header_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "included_header_names", value)

    @property
    @pulumi.getter(name="includedQueryParameters")
    def included_query_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Names of query string parameters to include in cache keys. All other parameters will be excluded.
        Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.
        """
        return pulumi.get(self, "included_query_parameters")

    @included_query_parameters.setter
    def included_query_parameters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "included_query_parameters", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs:
    def __init__(__self__, *,
                 allowed_signature_algorithms: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 token_query_parameter: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_signature_algorithms: The allowed signature algorithms to use.
               Defaults to using only ED25519.
               You may specify up to 3 signature algorithms to use.
               Each value may be one of: `ED25519`, `HMAC_SHA_256`, `HMAC_SHA1`.
        :param pulumi.Input[str] token_query_parameter: The query parameter in which to find the token.
               The name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.
               Defaults to `edge-cache-token`.
        """
        if allowed_signature_algorithms is not None:
            pulumi.set(__self__, "allowed_signature_algorithms", allowed_signature_algorithms)
        if token_query_parameter is not None:
            pulumi.set(__self__, "token_query_parameter", token_query_parameter)

    @property
    @pulumi.getter(name="allowedSignatureAlgorithms")
    def allowed_signature_algorithms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The allowed signature algorithms to use.
        Defaults to using only ED25519.
        You may specify up to 3 signature algorithms to use.
        Each value may be one of: `ED25519`, `HMAC_SHA_256`, `HMAC_SHA1`.
        """
        return pulumi.get(self, "allowed_signature_algorithms")

    @allowed_signature_algorithms.setter
    def allowed_signature_algorithms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_signature_algorithms", value)

    @property
    @pulumi.getter(name="tokenQueryParameter")
    def token_query_parameter(self) -> Optional[pulumi.Input[str]]:
        """
        The query parameter in which to find the token.
        The name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.
        Defaults to `edge-cache-token`.
        """
        return pulumi.get(self, "token_query_parameter")

    @token_query_parameter.setter
    def token_query_parameter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "token_query_parameter", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs:
    def __init__(__self__, *,
                 max_age: pulumi.Input[str],
                 allow_credentials: Optional[pulumi.Input[bool]] = None,
                 allow_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 disabled: Optional[pulumi.Input[bool]] = None,
                 expose_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] max_age: Specifies how long results of a preflight request can be cached by a client in seconds. Note that many browser clients enforce a maximum TTL of 600s (10 minutes).
               - Setting the value to -1 forces a pre-flight check for all requests (not recommended)
               - A maximum TTL of 86400s can be set, but note that (as above) some clients may force pre-flight checks at a more regular interval.
               - This translates to the Access-Control-Max-Age header.
               A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
        :param pulumi.Input[bool] allow_credentials: In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
               This translates to the Access-Control-Allow-Credentials response header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_headers: Specifies the content for the Access-Control-Allow-Headers response header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_methods: Specifies the content for the Access-Control-Allow-Methods response header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origins: Specifies the list of origins that will be allowed to do CORS requests.
               This translates to the Access-Control-Allow-Origin response header.
        :param pulumi.Input[bool] disabled: If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] expose_headers: Specifies the content for the Access-Control-Allow-Headers response header.
        """
        pulumi.set(__self__, "max_age", max_age)
        if allow_credentials is not None:
            pulumi.set(__self__, "allow_credentials", allow_credentials)
        if allow_headers is not None:
            pulumi.set(__self__, "allow_headers", allow_headers)
        if allow_methods is not None:
            pulumi.set(__self__, "allow_methods", allow_methods)
        if allow_origins is not None:
            pulumi.set(__self__, "allow_origins", allow_origins)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if expose_headers is not None:
            pulumi.set(__self__, "expose_headers", expose_headers)

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> pulumi.Input[str]:
        """
        Specifies how long results of a preflight request can be cached by a client in seconds. Note that many browser clients enforce a maximum TTL of 600s (10 minutes).
        - Setting the value to -1 forces a pre-flight check for all requests (not recommended)
        - A maximum TTL of 86400s can be set, but note that (as above) some clients may force pre-flight checks at a more regular interval.
        - This translates to the Access-Control-Max-Age header.
        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
        """
        return pulumi.get(self, "max_age")

    @max_age.setter
    def max_age(self, value: pulumi.Input[str]):
        pulumi.set(self, "max_age", value)

    @property
    @pulumi.getter(name="allowCredentials")
    def allow_credentials(self) -> Optional[pulumi.Input[bool]]:
        """
        In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
        This translates to the Access-Control-Allow-Credentials response header.
        """
        return pulumi.get(self, "allow_credentials")

    @allow_credentials.setter
    def allow_credentials(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_credentials", value)

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Headers response header.
        """
        return pulumi.get(self, "allow_headers")

    @allow_headers.setter
    def allow_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_headers", value)

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Methods response header.
        """
        return pulumi.get(self, "allow_methods")

    @allow_methods.setter
    def allow_methods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_methods", value)

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the list of origins that will be allowed to do CORS requests.
        This translates to the Access-Control-Allow-Origin response header.
        """
        return pulumi.get(self, "allow_origins")

    @allow_origins.setter
    def allow_origins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origins", value)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for the Access-Control-Allow-Headers response header.
        """
        return pulumi.get(self, "expose_headers")

    @expose_headers.setter
    def expose_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "expose_headers", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs:
    def __init__(__self__, *,
                 host_rewrite: Optional[pulumi.Input[str]] = None,
                 path_prefix_rewrite: Optional[pulumi.Input[str]] = None,
                 path_template_rewrite: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_rewrite: Prior to forwarding the request to the selected origin, the request's host header is replaced with contents of hostRewrite.
        :param pulumi.Input[str] path_prefix_rewrite: Prior to forwarding the request to the selected origin, the matching portion of the request's path is replaced by pathPrefixRewrite.
        :param pulumi.Input[str] path_template_rewrite: Prior to forwarding the request to the selected origin, if the
               request matched a pathTemplateMatch, the matching portion of the
               request's path is replaced re-written using the pattern specified
               by pathTemplateRewrite.
               pathTemplateRewrite must be between 1 and 255 characters
               (inclusive), must start with a '/', and must only use variables
               captured by the route's pathTemplate matchers.
               pathTemplateRewrite may only be used when all of a route's
               MatchRules specify pathTemplate.
               Only one of pathPrefixRewrite and pathTemplateRewrite may be
               specified.
        """
        if host_rewrite is not None:
            pulumi.set(__self__, "host_rewrite", host_rewrite)
        if path_prefix_rewrite is not None:
            pulumi.set(__self__, "path_prefix_rewrite", path_prefix_rewrite)
        if path_template_rewrite is not None:
            pulumi.set(__self__, "path_template_rewrite", path_template_rewrite)

    @property
    @pulumi.getter(name="hostRewrite")
    def host_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected origin, the request's host header is replaced with contents of hostRewrite.
        """
        return pulumi.get(self, "host_rewrite")

    @host_rewrite.setter
    def host_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_rewrite", value)

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected origin, the matching portion of the request's path is replaced by pathPrefixRewrite.
        """
        return pulumi.get(self, "path_prefix_rewrite")

    @path_prefix_rewrite.setter
    def path_prefix_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_prefix_rewrite", value)

    @property
    @pulumi.getter(name="pathTemplateRewrite")
    def path_template_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected origin, if the
        request matched a pathTemplateMatch, the matching portion of the
        request's path is replaced re-written using the pattern specified
        by pathTemplateRewrite.
        pathTemplateRewrite must be between 1 and 255 characters
        (inclusive), must start with a '/', and must only use variables
        captured by the route's pathTemplate matchers.
        pathTemplateRewrite may only be used when all of a route's
        MatchRules specify pathTemplate.
        Only one of pathPrefixRewrite and pathTemplateRewrite may be
        specified.
        """
        return pulumi.get(self, "path_template_rewrite")

    @path_template_rewrite.setter
    def path_template_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_template_rewrite", value)


@pulumi.input_type
class EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs:
    def __init__(__self__, *,
                 host_redirect: Optional[pulumi.Input[str]] = None,
                 https_redirect: Optional[pulumi.Input[bool]] = None,
                 path_redirect: Optional[pulumi.Input[str]] = None,
                 prefix_redirect: Optional[pulumi.Input[str]] = None,
                 redirect_response_code: Optional[pulumi.Input[str]] = None,
                 strip_query: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] host_redirect: The host that will be used in the redirect response instead of the one that was supplied in the request.
        :param pulumi.Input[bool] https_redirect: If set to true, the URL scheme in the redirected request is set to https. If set to false, the URL scheme of the redirected request will remain the same as that of the request.
               This can only be set if there is at least one (1) edgeSslCertificate set on the service.
        :param pulumi.Input[str] path_redirect: The path that will be used in the redirect response instead of the one that was supplied in the request.
               pathRedirect cannot be supplied together with prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.
               The path value must be between 1 and 1024 characters.
        :param pulumi.Input[str] prefix_redirect: The prefix that replaces the prefixMatch specified in the routeRule, retaining the remaining portion of the URL before redirecting the request.
               prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.
        :param pulumi.Input[str] redirect_response_code: The HTTP Status code to use for this RedirectAction.
               The supported values are:
        :param pulumi.Input[bool] strip_query: If set to true, any accompanying query portion of the original URL is removed prior to redirecting the request. If set to false, the query portion of the original URL is retained.
               
               - - -
        """
        if host_redirect is not None:
            pulumi.set(__self__, "host_redirect", host_redirect)
        if https_redirect is not None:
            pulumi.set(__self__, "https_redirect", https_redirect)
        if path_redirect is not None:
            pulumi.set(__self__, "path_redirect", path_redirect)
        if prefix_redirect is not None:
            pulumi.set(__self__, "prefix_redirect", prefix_redirect)
        if redirect_response_code is not None:
            pulumi.set(__self__, "redirect_response_code", redirect_response_code)
        if strip_query is not None:
            pulumi.set(__self__, "strip_query", strip_query)

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The host that will be used in the redirect response instead of the one that was supplied in the request.
        """
        return pulumi.get(self, "host_redirect")

    @host_redirect.setter
    def host_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_redirect", value)

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, the URL scheme in the redirected request is set to https. If set to false, the URL scheme of the redirected request will remain the same as that of the request.
        This can only be set if there is at least one (1) edgeSslCertificate set on the service.
        """
        return pulumi.get(self, "https_redirect")

    @https_redirect.setter
    def https_redirect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "https_redirect", value)

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The path that will be used in the redirect response instead of the one that was supplied in the request.
        pathRedirect cannot be supplied together with prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.
        The path value must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "path_redirect")

    @path_redirect.setter
    def path_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_redirect", value)

    @property
    @pulumi.getter(name="prefixRedirect")
    def prefix_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The prefix that replaces the prefixMatch specified in the routeRule, retaining the remaining portion of the URL before redirecting the request.
        prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.
        """
        return pulumi.get(self, "prefix_redirect")

    @prefix_redirect.setter
    def prefix_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_redirect", value)

    @property
    @pulumi.getter(name="redirectResponseCode")
    def redirect_response_code(self) -> Optional[pulumi.Input[str]]:
        """
        The HTTP Status code to use for this RedirectAction.
        The supported values are:
        """
        return pulumi.get(self, "redirect_response_code")

    @redirect_response_code.setter
    def redirect_response_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redirect_response_code", value)

    @property
    @pulumi.getter(name="stripQuery")
    def strip_query(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, any accompanying query portion of the original URL is removed prior to redirecting the request. If set to false, the query portion of the original URL is retained.

        - - -
        """
        return pulumi.get(self, "strip_query")

    @strip_query.setter
    def strip_query(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "strip_query", value)


@pulumi.input_type
class EndpointPolicyEndpointMatcherArgs:
    def __init__(__self__, *,
                 metadata_label_matcher: pulumi.Input['EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs']):
        """
        :param pulumi.Input['EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs'] metadata_label_matcher: The matcher is based on node metadata presented by xDS clients.
               Structure is documented below.
        """
        pulumi.set(__self__, "metadata_label_matcher", metadata_label_matcher)

    @property
    @pulumi.getter(name="metadataLabelMatcher")
    def metadata_label_matcher(self) -> pulumi.Input['EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs']:
        """
        The matcher is based on node metadata presented by xDS clients.
        Structure is documented below.
        """
        return pulumi.get(self, "metadata_label_matcher")

    @metadata_label_matcher.setter
    def metadata_label_matcher(self, value: pulumi.Input['EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs']):
        pulumi.set(self, "metadata_label_matcher", value)


@pulumi.input_type
class EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs:
    def __init__(__self__, *,
                 metadata_label_match_criteria: pulumi.Input[str],
                 metadata_labels: Optional[pulumi.Input[Sequence[pulumi.Input['EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs']]]] = None):
        """
        :param pulumi.Input[str] metadata_label_match_criteria: Specifies how matching should be done.
               Possible values are: `MATCH_ANY`, `MATCH_ALL`.
        :param pulumi.Input[Sequence[pulumi.Input['EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs']]] metadata_labels: The list of label value pairs that must match labels in the provided metadata based on filterMatchCriteria
               Structure is documented below.
        """
        pulumi.set(__self__, "metadata_label_match_criteria", metadata_label_match_criteria)
        if metadata_labels is not None:
            pulumi.set(__self__, "metadata_labels", metadata_labels)

    @property
    @pulumi.getter(name="metadataLabelMatchCriteria")
    def metadata_label_match_criteria(self) -> pulumi.Input[str]:
        """
        Specifies how matching should be done.
        Possible values are: `MATCH_ANY`, `MATCH_ALL`.
        """
        return pulumi.get(self, "metadata_label_match_criteria")

    @metadata_label_match_criteria.setter
    def metadata_label_match_criteria(self, value: pulumi.Input[str]):
        pulumi.set(self, "metadata_label_match_criteria", value)

    @property
    @pulumi.getter(name="metadataLabels")
    def metadata_labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs']]]]:
        """
        The list of label value pairs that must match labels in the provided metadata based on filterMatchCriteria
        Structure is documented below.
        """
        return pulumi.get(self, "metadata_labels")

    @metadata_labels.setter
    def metadata_labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs']]]]):
        pulumi.set(self, "metadata_labels", value)


@pulumi.input_type
class EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs:
    def __init__(__self__, *,
                 label_name: pulumi.Input[str],
                 label_value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] label_name: Required. Label name presented as key in xDS Node Metadata.
        :param pulumi.Input[str] label_value: Required. Label value presented as value corresponding to the above key, in xDS Node Metadata.
               
               - - -
        """
        pulumi.set(__self__, "label_name", label_name)
        pulumi.set(__self__, "label_value", label_value)

    @property
    @pulumi.getter(name="labelName")
    def label_name(self) -> pulumi.Input[str]:
        """
        Required. Label name presented as key in xDS Node Metadata.
        """
        return pulumi.get(self, "label_name")

    @label_name.setter
    def label_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "label_name", value)

    @property
    @pulumi.getter(name="labelValue")
    def label_value(self) -> pulumi.Input[str]:
        """
        Required. Label value presented as value corresponding to the above key, in xDS Node Metadata.

        - - -
        """
        return pulumi.get(self, "label_value")

    @label_value.setter
    def label_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "label_value", value)


@pulumi.input_type
class EndpointPolicyTrafficPortSelectorArgs:
    def __init__(__self__, *,
                 ports: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ports: List of ports. Can be port numbers or port range (example, [80-90] specifies all ports from 80 to 90, including 80 and 90) or named ports or * to specify all ports. If the list is empty, all ports are selected.
        """
        pulumi.set(__self__, "ports", ports)

    @property
    @pulumi.getter
    def ports(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        List of ports. Can be port numbers or port range (example, [80-90] specifies all ports from 80 to 90, including 80 and 90) or named ports or * to specify all ports. If the list is empty, all ports are selected.
        """
        return pulumi.get(self, "ports")

    @ports.setter
    def ports(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "ports", value)


@pulumi.input_type
class GrpcRouteRuleArgs:
    def __init__(__self__, *,
                 action: Optional[pulumi.Input['GrpcRouteRuleActionArgs']] = None,
                 matches: Optional[pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleMatchArgs']]]] = None):
        """
        :param pulumi.Input['GrpcRouteRuleActionArgs'] action: Required. A detailed rule defining how to route traffic.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleMatchArgs']]] matches: Matches define conditions used for matching the rule against incoming gRPC requests.
               Structure is documented below.
        """
        if action is not None:
            pulumi.set(__self__, "action", action)
        if matches is not None:
            pulumi.set(__self__, "matches", matches)

    @property
    @pulumi.getter
    def action(self) -> Optional[pulumi.Input['GrpcRouteRuleActionArgs']]:
        """
        Required. A detailed rule defining how to route traffic.
        Structure is documented below.
        """
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: Optional[pulumi.Input['GrpcRouteRuleActionArgs']]):
        pulumi.set(self, "action", value)

    @property
    @pulumi.getter
    def matches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleMatchArgs']]]]:
        """
        Matches define conditions used for matching the rule against incoming gRPC requests.
        Structure is documented below.
        """
        return pulumi.get(self, "matches")

    @matches.setter
    def matches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleMatchArgs']]]]):
        pulumi.set(self, "matches", value)


@pulumi.input_type
class GrpcRouteRuleActionArgs:
    def __init__(__self__, *,
                 destinations: Optional[pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleActionDestinationArgs']]]] = None,
                 fault_injection_policy: Optional[pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyArgs']] = None,
                 retry_policy: Optional[pulumi.Input['GrpcRouteRuleActionRetryPolicyArgs']] = None,
                 timeout: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleActionDestinationArgs']]] destinations: The destination to which traffic should be forwarded.
               Structure is documented below.
        :param pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyArgs'] fault_injection_policy: The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
               Structure is documented below.
        :param pulumi.Input['GrpcRouteRuleActionRetryPolicyArgs'] retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param pulumi.Input[str] timeout: Specifies the timeout for selected route.
        """
        if destinations is not None:
            pulumi.set(__self__, "destinations", destinations)
        if fault_injection_policy is not None:
            pulumi.set(__self__, "fault_injection_policy", fault_injection_policy)
        if retry_policy is not None:
            pulumi.set(__self__, "retry_policy", retry_policy)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def destinations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleActionDestinationArgs']]]]:
        """
        The destination to which traffic should be forwarded.
        Structure is documented below.
        """
        return pulumi.get(self, "destinations")

    @destinations.setter
    def destinations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleActionDestinationArgs']]]]):
        pulumi.set(self, "destinations", value)

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional[pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyArgs']]:
        """
        The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
        Structure is documented below.
        """
        return pulumi.get(self, "fault_injection_policy")

    @fault_injection_policy.setter
    def fault_injection_policy(self, value: Optional[pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyArgs']]):
        pulumi.set(self, "fault_injection_policy", value)

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional[pulumi.Input['GrpcRouteRuleActionRetryPolicyArgs']]:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @retry_policy.setter
    def retry_policy(self, value: Optional[pulumi.Input['GrpcRouteRuleActionRetryPolicyArgs']]):
        pulumi.set(self, "retry_policy", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the timeout for selected route.
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timeout", value)


@pulumi.input_type
class GrpcRouteRuleActionDestinationArgs:
    def __init__(__self__, *,
                 service_name: Optional[pulumi.Input[str]] = None,
                 weight: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] service_name: The URL of a BackendService to route traffic to.
        :param pulumi.Input[int] weight: Specifies the proportion of requests forwarded to the backend referenced by the serviceName field.
        """
        if service_name is not None:
            pulumi.set(__self__, "service_name", service_name)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> Optional[pulumi.Input[str]]:
        """
        The URL of a BackendService to route traffic to.
        """
        return pulumi.get(self, "service_name")

    @service_name.setter
    def service_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_name", value)

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the proportion of requests forwarded to the backend referenced by the serviceName field.
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "weight", value)


@pulumi.input_type
class GrpcRouteRuleActionFaultInjectionPolicyArgs:
    def __init__(__self__, *,
                 abort: Optional[pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyAbortArgs']] = None,
                 delay: Optional[pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyDelayArgs']] = None):
        """
        :param pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyAbortArgs'] abort: Specification of how client requests are aborted as part of fault injection before being sent to a destination.
               Structure is documented below.
        :param pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyDelayArgs'] delay: Specification of how client requests are delayed as part of fault injection before being sent to a destination.
               Structure is documented below.
        """
        if abort is not None:
            pulumi.set(__self__, "abort", abort)
        if delay is not None:
            pulumi.set(__self__, "delay", delay)

    @property
    @pulumi.getter
    def abort(self) -> Optional[pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyAbortArgs']]:
        """
        Specification of how client requests are aborted as part of fault injection before being sent to a destination.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @abort.setter
    def abort(self, value: Optional[pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyAbortArgs']]):
        pulumi.set(self, "abort", value)

    @property
    @pulumi.getter
    def delay(self) -> Optional[pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyDelayArgs']]:
        """
        Specification of how client requests are delayed as part of fault injection before being sent to a destination.
        Structure is documented below.
        """
        return pulumi.get(self, "delay")

    @delay.setter
    def delay(self, value: Optional[pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyDelayArgs']]):
        pulumi.set(self, "delay", value)


@pulumi.input_type
class GrpcRouteRuleActionFaultInjectionPolicyAbortArgs:
    def __init__(__self__, *,
                 http_status: Optional[pulumi.Input[int]] = None,
                 percentage: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] http_status: The HTTP status code used to abort the request.
        :param pulumi.Input[int] percentage: The percentage of traffic which will be aborted.
        """
        if http_status is not None:
            pulumi.set(__self__, "http_status", http_status)
        if percentage is not None:
            pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="httpStatus")
    def http_status(self) -> Optional[pulumi.Input[int]]:
        """
        The HTTP status code used to abort the request.
        """
        return pulumi.get(self, "http_status")

    @http_status.setter
    def http_status(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "http_status", value)

    @property
    @pulumi.getter
    def percentage(self) -> Optional[pulumi.Input[int]]:
        """
        The percentage of traffic which will be aborted.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class GrpcRouteRuleActionFaultInjectionPolicyDelayArgs:
    def __init__(__self__, *,
                 fixed_delay: Optional[pulumi.Input[str]] = None,
                 percentage: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] fixed_delay: Specify a fixed delay before forwarding the request.
        :param pulumi.Input[int] percentage: The percentage of traffic on which delay will be injected.
        """
        if fixed_delay is not None:
            pulumi.set(__self__, "fixed_delay", fixed_delay)
        if percentage is not None:
            pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="fixedDelay")
    def fixed_delay(self) -> Optional[pulumi.Input[str]]:
        """
        Specify a fixed delay before forwarding the request.
        """
        return pulumi.get(self, "fixed_delay")

    @fixed_delay.setter
    def fixed_delay(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "fixed_delay", value)

    @property
    @pulumi.getter
    def percentage(self) -> Optional[pulumi.Input[int]]:
        """
        The percentage of traffic on which delay will be injected.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class GrpcRouteRuleActionRetryPolicyArgs:
    def __init__(__self__, *,
                 num_retries: Optional[pulumi.Input[int]] = None,
                 retry_conditions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] num_retries: Specifies the allowed number of retries.
               
               - - -
        :param pulumi.Input[Sequence[pulumi.Input[str]]] retry_conditions: Specifies one or more conditions when this retry policy applies.
               Each value may be one of: `connect-failure`, `refused-stream`, `cancelled`, `deadline-exceeded`, `resource-exhausted`, `unavailable`.
        """
        if num_retries is not None:
            pulumi.set(__self__, "num_retries", num_retries)
        if retry_conditions is not None:
            pulumi.set(__self__, "retry_conditions", retry_conditions)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the allowed number of retries.

        - - -
        """
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_retries", value)

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies one or more conditions when this retry policy applies.
        Each value may be one of: `connect-failure`, `refused-stream`, `cancelled`, `deadline-exceeded`, `resource-exhausted`, `unavailable`.
        """
        return pulumi.get(self, "retry_conditions")

    @retry_conditions.setter
    def retry_conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "retry_conditions", value)


@pulumi.input_type
class GrpcRouteRuleMatchArgs:
    def __init__(__self__, *,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleMatchHeaderArgs']]]] = None,
                 method: Optional[pulumi.Input['GrpcRouteRuleMatchMethodArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleMatchHeaderArgs']]] headers: Specifies a list of HTTP request headers to match against.
               Structure is documented below.
        :param pulumi.Input['GrpcRouteRuleMatchMethodArgs'] method: A gRPC method to match against. If this field is empty or omitted, will match all methods.
               Structure is documented below.
        """
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if method is not None:
            pulumi.set(__self__, "method", method)

    @property
    @pulumi.getter
    def headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleMatchHeaderArgs']]]]:
        """
        Specifies a list of HTTP request headers to match against.
        Structure is documented below.
        """
        return pulumi.get(self, "headers")

    @headers.setter
    def headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleMatchHeaderArgs']]]]):
        pulumi.set(self, "headers", value)

    @property
    @pulumi.getter
    def method(self) -> Optional[pulumi.Input['GrpcRouteRuleMatchMethodArgs']]:
        """
        A gRPC method to match against. If this field is empty or omitted, will match all methods.
        Structure is documented below.
        """
        return pulumi.get(self, "method")

    @method.setter
    def method(self, value: Optional[pulumi.Input['GrpcRouteRuleMatchMethodArgs']]):
        pulumi.set(self, "method", value)


@pulumi.input_type
class GrpcRouteRuleMatchHeaderArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str],
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key: Required. The key of the header.
        :param pulumi.Input[str] value: Required. The value of the header.
        :param pulumi.Input[str] type: The type of match.
               Default value is `EXACT`.
               Possible values are: `TYPE_UNSPECIFIED`, `EXACT`, `REGULAR_EXPRESSION`.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Required. The key of the header.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        Required. The value of the header.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of match.
        Default value is `EXACT`.
        Possible values are: `TYPE_UNSPECIFIED`, `EXACT`, `REGULAR_EXPRESSION`.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class GrpcRouteRuleMatchMethodArgs:
    def __init__(__self__, *,
                 grpc_method: pulumi.Input[str],
                 grpc_service: pulumi.Input[str],
                 case_sensitive: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] grpc_method: Required. Name of the method to match against.
        :param pulumi.Input[str] grpc_service: Required. Name of the service to match against.
        :param pulumi.Input[bool] case_sensitive: Specifies that matches are case sensitive. The default value is true.
        """
        pulumi.set(__self__, "grpc_method", grpc_method)
        pulumi.set(__self__, "grpc_service", grpc_service)
        if case_sensitive is not None:
            pulumi.set(__self__, "case_sensitive", case_sensitive)

    @property
    @pulumi.getter(name="grpcMethod")
    def grpc_method(self) -> pulumi.Input[str]:
        """
        Required. Name of the method to match against.
        """
        return pulumi.get(self, "grpc_method")

    @grpc_method.setter
    def grpc_method(self, value: pulumi.Input[str]):
        pulumi.set(self, "grpc_method", value)

    @property
    @pulumi.getter(name="grpcService")
    def grpc_service(self) -> pulumi.Input[str]:
        """
        Required. Name of the service to match against.
        """
        return pulumi.get(self, "grpc_service")

    @grpc_service.setter
    def grpc_service(self, value: pulumi.Input[str]):
        pulumi.set(self, "grpc_service", value)

    @property
    @pulumi.getter(name="caseSensitive")
    def case_sensitive(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies that matches are case sensitive. The default value is true.
        """
        return pulumi.get(self, "case_sensitive")

    @case_sensitive.setter
    def case_sensitive(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "case_sensitive", value)


@pulumi.input_type
class HttpRouteRuleArgs:
    def __init__(__self__, *,
                 action: Optional[pulumi.Input['HttpRouteRuleActionArgs']] = None,
                 matches: Optional[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchArgs']]]] = None):
        """
        :param pulumi.Input['HttpRouteRuleActionArgs'] action: The detailed rule defining how to route matched traffic.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchArgs']]] matches: A list of matches define conditions used for matching the rule against incoming HTTP requests. Each match is independent, i.e. this rule will be matched if ANY one of the matches is satisfied.
               If no matches field is specified, this rule will unconditionally match traffic.
               If a default rule is desired to be configured, add a rule with no matches specified to the end of the rules list.
               Structure is documented below.
        """
        if action is not None:
            pulumi.set(__self__, "action", action)
        if matches is not None:
            pulumi.set(__self__, "matches", matches)

    @property
    @pulumi.getter
    def action(self) -> Optional[pulumi.Input['HttpRouteRuleActionArgs']]:
        """
        The detailed rule defining how to route matched traffic.
        Structure is documented below.
        """
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: Optional[pulumi.Input['HttpRouteRuleActionArgs']]):
        pulumi.set(self, "action", value)

    @property
    @pulumi.getter
    def matches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchArgs']]]]:
        """
        A list of matches define conditions used for matching the rule against incoming HTTP requests. Each match is independent, i.e. this rule will be matched if ANY one of the matches is satisfied.
        If no matches field is specified, this rule will unconditionally match traffic.
        If a default rule is desired to be configured, add a rule with no matches specified to the end of the rules list.
        Structure is documented below.
        """
        return pulumi.get(self, "matches")

    @matches.setter
    def matches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchArgs']]]]):
        pulumi.set(self, "matches", value)


@pulumi.input_type
class HttpRouteRuleActionArgs:
    def __init__(__self__, *,
                 cors_policy: Optional[pulumi.Input['HttpRouteRuleActionCorsPolicyArgs']] = None,
                 destinations: Optional[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleActionDestinationArgs']]]] = None,
                 fault_injection_policy: Optional[pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyArgs']] = None,
                 redirect: Optional[pulumi.Input['HttpRouteRuleActionRedirectArgs']] = None,
                 request_header_modifier: Optional[pulumi.Input['HttpRouteRuleActionRequestHeaderModifierArgs']] = None,
                 request_mirror_policy: Optional[pulumi.Input['HttpRouteRuleActionRequestMirrorPolicyArgs']] = None,
                 response_header_modifier: Optional[pulumi.Input['HttpRouteRuleActionResponseHeaderModifierArgs']] = None,
                 retry_policy: Optional[pulumi.Input['HttpRouteRuleActionRetryPolicyArgs']] = None,
                 timeout: Optional[pulumi.Input[str]] = None,
                 url_rewrite: Optional[pulumi.Input['HttpRouteRuleActionUrlRewriteArgs']] = None):
        """
        :param pulumi.Input['HttpRouteRuleActionCorsPolicyArgs'] cors_policy: The specification for allowing client side cross-origin requests.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleActionDestinationArgs']]] destinations: The destination to which traffic should be forwarded.
               Structure is documented below.
        :param pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyArgs'] fault_injection_policy: The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
               Structure is documented below.
        :param pulumi.Input['HttpRouteRuleActionRedirectArgs'] redirect: If set, the request is directed as configured by this field.
               Structure is documented below.
        :param pulumi.Input['HttpRouteRuleActionRequestHeaderModifierArgs'] request_header_modifier: The specification for modifying the headers of a matching request prior to delivery of the request to the destination.
               Structure is documented below.
        :param pulumi.Input['HttpRouteRuleActionRequestMirrorPolicyArgs'] request_mirror_policy: Specifies the policy on how requests intended for the routes destination are shadowed to a separate mirrored destination.
               Structure is documented below.
        :param pulumi.Input['HttpRouteRuleActionResponseHeaderModifierArgs'] response_header_modifier: The specification for modifying the headers of a response prior to sending the response back to the client.
               Structure is documented below.
        :param pulumi.Input['HttpRouteRuleActionRetryPolicyArgs'] retry_policy: Specifies the retry policy associated with this route.
               Structure is documented below.
        :param pulumi.Input[str] timeout: Specifies the timeout for selected route.
        :param pulumi.Input['HttpRouteRuleActionUrlRewriteArgs'] url_rewrite: The specification for rewrite URL before forwarding requests to the destination.
               Structure is documented below.
        """
        if cors_policy is not None:
            pulumi.set(__self__, "cors_policy", cors_policy)
        if destinations is not None:
            pulumi.set(__self__, "destinations", destinations)
        if fault_injection_policy is not None:
            pulumi.set(__self__, "fault_injection_policy", fault_injection_policy)
        if redirect is not None:
            pulumi.set(__self__, "redirect", redirect)
        if request_header_modifier is not None:
            pulumi.set(__self__, "request_header_modifier", request_header_modifier)
        if request_mirror_policy is not None:
            pulumi.set(__self__, "request_mirror_policy", request_mirror_policy)
        if response_header_modifier is not None:
            pulumi.set(__self__, "response_header_modifier", response_header_modifier)
        if retry_policy is not None:
            pulumi.set(__self__, "retry_policy", retry_policy)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if url_rewrite is not None:
            pulumi.set(__self__, "url_rewrite", url_rewrite)

    @property
    @pulumi.getter(name="corsPolicy")
    def cors_policy(self) -> Optional[pulumi.Input['HttpRouteRuleActionCorsPolicyArgs']]:
        """
        The specification for allowing client side cross-origin requests.
        Structure is documented below.
        """
        return pulumi.get(self, "cors_policy")

    @cors_policy.setter
    def cors_policy(self, value: Optional[pulumi.Input['HttpRouteRuleActionCorsPolicyArgs']]):
        pulumi.set(self, "cors_policy", value)

    @property
    @pulumi.getter
    def destinations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleActionDestinationArgs']]]]:
        """
        The destination to which traffic should be forwarded.
        Structure is documented below.
        """
        return pulumi.get(self, "destinations")

    @destinations.setter
    def destinations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleActionDestinationArgs']]]]):
        pulumi.set(self, "destinations", value)

    @property
    @pulumi.getter(name="faultInjectionPolicy")
    def fault_injection_policy(self) -> Optional[pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyArgs']]:
        """
        The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
        Structure is documented below.
        """
        return pulumi.get(self, "fault_injection_policy")

    @fault_injection_policy.setter
    def fault_injection_policy(self, value: Optional[pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyArgs']]):
        pulumi.set(self, "fault_injection_policy", value)

    @property
    @pulumi.getter
    def redirect(self) -> Optional[pulumi.Input['HttpRouteRuleActionRedirectArgs']]:
        """
        If set, the request is directed as configured by this field.
        Structure is documented below.
        """
        return pulumi.get(self, "redirect")

    @redirect.setter
    def redirect(self, value: Optional[pulumi.Input['HttpRouteRuleActionRedirectArgs']]):
        pulumi.set(self, "redirect", value)

    @property
    @pulumi.getter(name="requestHeaderModifier")
    def request_header_modifier(self) -> Optional[pulumi.Input['HttpRouteRuleActionRequestHeaderModifierArgs']]:
        """
        The specification for modifying the headers of a matching request prior to delivery of the request to the destination.
        Structure is documented below.
        """
        return pulumi.get(self, "request_header_modifier")

    @request_header_modifier.setter
    def request_header_modifier(self, value: Optional[pulumi.Input['HttpRouteRuleActionRequestHeaderModifierArgs']]):
        pulumi.set(self, "request_header_modifier", value)

    @property
    @pulumi.getter(name="requestMirrorPolicy")
    def request_mirror_policy(self) -> Optional[pulumi.Input['HttpRouteRuleActionRequestMirrorPolicyArgs']]:
        """
        Specifies the policy on how requests intended for the routes destination are shadowed to a separate mirrored destination.
        Structure is documented below.
        """
        return pulumi.get(self, "request_mirror_policy")

    @request_mirror_policy.setter
    def request_mirror_policy(self, value: Optional[pulumi.Input['HttpRouteRuleActionRequestMirrorPolicyArgs']]):
        pulumi.set(self, "request_mirror_policy", value)

    @property
    @pulumi.getter(name="responseHeaderModifier")
    def response_header_modifier(self) -> Optional[pulumi.Input['HttpRouteRuleActionResponseHeaderModifierArgs']]:
        """
        The specification for modifying the headers of a response prior to sending the response back to the client.
        Structure is documented below.
        """
        return pulumi.get(self, "response_header_modifier")

    @response_header_modifier.setter
    def response_header_modifier(self, value: Optional[pulumi.Input['HttpRouteRuleActionResponseHeaderModifierArgs']]):
        pulumi.set(self, "response_header_modifier", value)

    @property
    @pulumi.getter(name="retryPolicy")
    def retry_policy(self) -> Optional[pulumi.Input['HttpRouteRuleActionRetryPolicyArgs']]:
        """
        Specifies the retry policy associated with this route.
        Structure is documented below.
        """
        return pulumi.get(self, "retry_policy")

    @retry_policy.setter
    def retry_policy(self, value: Optional[pulumi.Input['HttpRouteRuleActionRetryPolicyArgs']]):
        pulumi.set(self, "retry_policy", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the timeout for selected route.
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timeout", value)

    @property
    @pulumi.getter(name="urlRewrite")
    def url_rewrite(self) -> Optional[pulumi.Input['HttpRouteRuleActionUrlRewriteArgs']]:
        """
        The specification for rewrite URL before forwarding requests to the destination.
        Structure is documented below.
        """
        return pulumi.get(self, "url_rewrite")

    @url_rewrite.setter
    def url_rewrite(self, value: Optional[pulumi.Input['HttpRouteRuleActionUrlRewriteArgs']]):
        pulumi.set(self, "url_rewrite", value)


@pulumi.input_type
class HttpRouteRuleActionCorsPolicyArgs:
    def __init__(__self__, *,
                 allow_credentials: Optional[pulumi.Input[bool]] = None,
                 allow_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_methods: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origin_regexes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allow_origins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 disabled: Optional[pulumi.Input[bool]] = None,
                 expose_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 max_age: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] allow_credentials: In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_headers: Specifies the content for Access-Control-Allow-Headers header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_methods: Specifies the content for Access-Control-Allow-Methods header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origin_regexes: Specifies the regular expression patterns that match allowed origins.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] allow_origins: Specifies the list of origins that will be allowed to do CORS requests.
        :param pulumi.Input[bool] disabled: If true, the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
               
               - - -
        :param pulumi.Input[Sequence[pulumi.Input[str]]] expose_headers: Specifies the content for Access-Control-Expose-Headers header.
        :param pulumi.Input[str] max_age: Specifies how long result of a preflight request can be cached in seconds.
        """
        if allow_credentials is not None:
            pulumi.set(__self__, "allow_credentials", allow_credentials)
        if allow_headers is not None:
            pulumi.set(__self__, "allow_headers", allow_headers)
        if allow_methods is not None:
            pulumi.set(__self__, "allow_methods", allow_methods)
        if allow_origin_regexes is not None:
            pulumi.set(__self__, "allow_origin_regexes", allow_origin_regexes)
        if allow_origins is not None:
            pulumi.set(__self__, "allow_origins", allow_origins)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if expose_headers is not None:
            pulumi.set(__self__, "expose_headers", expose_headers)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)

    @property
    @pulumi.getter(name="allowCredentials")
    def allow_credentials(self) -> Optional[pulumi.Input[bool]]:
        """
        In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
        """
        return pulumi.get(self, "allow_credentials")

    @allow_credentials.setter
    def allow_credentials(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_credentials", value)

    @property
    @pulumi.getter(name="allowHeaders")
    def allow_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for Access-Control-Allow-Headers header.
        """
        return pulumi.get(self, "allow_headers")

    @allow_headers.setter
    def allow_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_headers", value)

    @property
    @pulumi.getter(name="allowMethods")
    def allow_methods(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for Access-Control-Allow-Methods header.
        """
        return pulumi.get(self, "allow_methods")

    @allow_methods.setter
    def allow_methods(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_methods", value)

    @property
    @pulumi.getter(name="allowOriginRegexes")
    def allow_origin_regexes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the regular expression patterns that match allowed origins.
        """
        return pulumi.get(self, "allow_origin_regexes")

    @allow_origin_regexes.setter
    def allow_origin_regexes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origin_regexes", value)

    @property
    @pulumi.getter(name="allowOrigins")
    def allow_origins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the list of origins that will be allowed to do CORS requests.
        """
        return pulumi.get(self, "allow_origins")

    @allow_origins.setter
    def allow_origins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allow_origins", value)

    @property
    @pulumi.getter
    def disabled(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.

        - - -
        """
        return pulumi.get(self, "disabled")

    @disabled.setter
    def disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disabled", value)

    @property
    @pulumi.getter(name="exposeHeaders")
    def expose_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies the content for Access-Control-Expose-Headers header.
        """
        return pulumi.get(self, "expose_headers")

    @expose_headers.setter
    def expose_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "expose_headers", value)

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how long result of a preflight request can be cached in seconds.
        """
        return pulumi.get(self, "max_age")

    @max_age.setter
    def max_age(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_age", value)


@pulumi.input_type
class HttpRouteRuleActionDestinationArgs:
    def __init__(__self__, *,
                 service_name: Optional[pulumi.Input[str]] = None,
                 weight: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] service_name: The URL of a BackendService to route traffic to.
        :param pulumi.Input[int] weight: Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
               If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
               If weights are specified for any one service name, they need to be specified for all of them.
               If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
        """
        if service_name is not None:
            pulumi.set(__self__, "service_name", service_name)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> Optional[pulumi.Input[str]]:
        """
        The URL of a BackendService to route traffic to.
        """
        return pulumi.get(self, "service_name")

    @service_name.setter
    def service_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_name", value)

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
        If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
        If weights are specified for any one service name, they need to be specified for all of them.
        If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "weight", value)


@pulumi.input_type
class HttpRouteRuleActionFaultInjectionPolicyArgs:
    def __init__(__self__, *,
                 abort: Optional[pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyAbortArgs']] = None,
                 delay: Optional[pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyDelayArgs']] = None):
        """
        :param pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyAbortArgs'] abort: Specification of how client requests are aborted as part of fault injection before being sent to a destination.
               Structure is documented below.
        :param pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyDelayArgs'] delay: Specification of how client requests are delayed as part of fault injection before being sent to a destination.
               Structure is documented below.
        """
        if abort is not None:
            pulumi.set(__self__, "abort", abort)
        if delay is not None:
            pulumi.set(__self__, "delay", delay)

    @property
    @pulumi.getter
    def abort(self) -> Optional[pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyAbortArgs']]:
        """
        Specification of how client requests are aborted as part of fault injection before being sent to a destination.
        Structure is documented below.
        """
        return pulumi.get(self, "abort")

    @abort.setter
    def abort(self, value: Optional[pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyAbortArgs']]):
        pulumi.set(self, "abort", value)

    @property
    @pulumi.getter
    def delay(self) -> Optional[pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyDelayArgs']]:
        """
        Specification of how client requests are delayed as part of fault injection before being sent to a destination.
        Structure is documented below.
        """
        return pulumi.get(self, "delay")

    @delay.setter
    def delay(self, value: Optional[pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyDelayArgs']]):
        pulumi.set(self, "delay", value)


@pulumi.input_type
class HttpRouteRuleActionFaultInjectionPolicyAbortArgs:
    def __init__(__self__, *,
                 http_status: Optional[pulumi.Input[int]] = None,
                 percentage: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] http_status: The HTTP status code used to abort the request.
        :param pulumi.Input[int] percentage: The percentage of traffic which will be aborted.
        """
        if http_status is not None:
            pulumi.set(__self__, "http_status", http_status)
        if percentage is not None:
            pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="httpStatus")
    def http_status(self) -> Optional[pulumi.Input[int]]:
        """
        The HTTP status code used to abort the request.
        """
        return pulumi.get(self, "http_status")

    @http_status.setter
    def http_status(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "http_status", value)

    @property
    @pulumi.getter
    def percentage(self) -> Optional[pulumi.Input[int]]:
        """
        The percentage of traffic which will be aborted.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class HttpRouteRuleActionFaultInjectionPolicyDelayArgs:
    def __init__(__self__, *,
                 fixed_delay: Optional[pulumi.Input[str]] = None,
                 percentage: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] fixed_delay: Specify a fixed delay before forwarding the request.
        :param pulumi.Input[int] percentage: The percentage of traffic on which delay will be injected.
        """
        if fixed_delay is not None:
            pulumi.set(__self__, "fixed_delay", fixed_delay)
        if percentage is not None:
            pulumi.set(__self__, "percentage", percentage)

    @property
    @pulumi.getter(name="fixedDelay")
    def fixed_delay(self) -> Optional[pulumi.Input[str]]:
        """
        Specify a fixed delay before forwarding the request.
        """
        return pulumi.get(self, "fixed_delay")

    @fixed_delay.setter
    def fixed_delay(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "fixed_delay", value)

    @property
    @pulumi.getter
    def percentage(self) -> Optional[pulumi.Input[int]]:
        """
        The percentage of traffic on which delay will be injected.
        """
        return pulumi.get(self, "percentage")

    @percentage.setter
    def percentage(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "percentage", value)


@pulumi.input_type
class HttpRouteRuleActionRedirectArgs:
    def __init__(__self__, *,
                 host_redirect: Optional[pulumi.Input[str]] = None,
                 https_redirect: Optional[pulumi.Input[bool]] = None,
                 path_redirect: Optional[pulumi.Input[str]] = None,
                 port_redirect: Optional[pulumi.Input[int]] = None,
                 prefix_rewrite: Optional[pulumi.Input[str]] = None,
                 response_code: Optional[pulumi.Input[str]] = None,
                 strip_query: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] host_redirect: The host that will be used in the redirect response instead of the one that was supplied in the request.
        :param pulumi.Input[bool] https_redirect: If set to true, the URL scheme in the redirected request is set to https.
        :param pulumi.Input[str] path_redirect: The path that will be used in the redirect response instead of the one that was supplied in the request. pathRedirect can not be supplied together with prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.
        :param pulumi.Input[int] port_redirect: The port that will be used in the redirected request instead of the one that was supplied in the request.
        :param pulumi.Input[str] prefix_rewrite: Indicates that during redirection, the matched prefix (or path) should be swapped with this value.
        :param pulumi.Input[str] response_code: The HTTP Status code to use for the redirect.
        :param pulumi.Input[bool] strip_query: If set to true, any accompanying query portion of the original URL is removed prior to redirecting the request.
        """
        if host_redirect is not None:
            pulumi.set(__self__, "host_redirect", host_redirect)
        if https_redirect is not None:
            pulumi.set(__self__, "https_redirect", https_redirect)
        if path_redirect is not None:
            pulumi.set(__self__, "path_redirect", path_redirect)
        if port_redirect is not None:
            pulumi.set(__self__, "port_redirect", port_redirect)
        if prefix_rewrite is not None:
            pulumi.set(__self__, "prefix_rewrite", prefix_rewrite)
        if response_code is not None:
            pulumi.set(__self__, "response_code", response_code)
        if strip_query is not None:
            pulumi.set(__self__, "strip_query", strip_query)

    @property
    @pulumi.getter(name="hostRedirect")
    def host_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The host that will be used in the redirect response instead of the one that was supplied in the request.
        """
        return pulumi.get(self, "host_redirect")

    @host_redirect.setter
    def host_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_redirect", value)

    @property
    @pulumi.getter(name="httpsRedirect")
    def https_redirect(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, the URL scheme in the redirected request is set to https.
        """
        return pulumi.get(self, "https_redirect")

    @https_redirect.setter
    def https_redirect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "https_redirect", value)

    @property
    @pulumi.getter(name="pathRedirect")
    def path_redirect(self) -> Optional[pulumi.Input[str]]:
        """
        The path that will be used in the redirect response instead of the one that was supplied in the request. pathRedirect can not be supplied together with prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.
        """
        return pulumi.get(self, "path_redirect")

    @path_redirect.setter
    def path_redirect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_redirect", value)

    @property
    @pulumi.getter(name="portRedirect")
    def port_redirect(self) -> Optional[pulumi.Input[int]]:
        """
        The port that will be used in the redirected request instead of the one that was supplied in the request.
        """
        return pulumi.get(self, "port_redirect")

    @port_redirect.setter
    def port_redirect(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port_redirect", value)

    @property
    @pulumi.getter(name="prefixRewrite")
    def prefix_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Indicates that during redirection, the matched prefix (or path) should be swapped with this value.
        """
        return pulumi.get(self, "prefix_rewrite")

    @prefix_rewrite.setter
    def prefix_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_rewrite", value)

    @property
    @pulumi.getter(name="responseCode")
    def response_code(self) -> Optional[pulumi.Input[str]]:
        """
        The HTTP Status code to use for the redirect.
        """
        return pulumi.get(self, "response_code")

    @response_code.setter
    def response_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "response_code", value)

    @property
    @pulumi.getter(name="stripQuery")
    def strip_query(self) -> Optional[pulumi.Input[bool]]:
        """
        If set to true, any accompanying query portion of the original URL is removed prior to redirecting the request.
        """
        return pulumi.get(self, "strip_query")

    @strip_query.setter
    def strip_query(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "strip_query", value)


@pulumi.input_type
class HttpRouteRuleActionRequestHeaderModifierArgs:
    def __init__(__self__, *,
                 add: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 set: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] add: Add the headers with given map where key is the name of the header, value is the value of the header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] removes: Remove headers (matching by header names) specified in the list.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] set: Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.
        """
        if add is not None:
            pulumi.set(__self__, "add", add)
        if removes is not None:
            pulumi.set(__self__, "removes", removes)
        if set is not None:
            pulumi.set(__self__, "set", set)

    @property
    @pulumi.getter
    def add(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Add the headers with given map where key is the name of the header, value is the value of the header.
        """
        return pulumi.get(self, "add")

    @add.setter
    def add(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "add", value)

    @property
    @pulumi.getter
    def removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Remove headers (matching by header names) specified in the list.
        """
        return pulumi.get(self, "removes")

    @removes.setter
    def removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "removes", value)

    @property
    @pulumi.getter
    def set(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.
        """
        return pulumi.get(self, "set")

    @set.setter
    def set(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "set", value)


@pulumi.input_type
class HttpRouteRuleActionRequestMirrorPolicyArgs:
    def __init__(__self__, *,
                 destination: Optional[pulumi.Input['HttpRouteRuleActionRequestMirrorPolicyDestinationArgs']] = None):
        """
        :param pulumi.Input['HttpRouteRuleActionRequestMirrorPolicyDestinationArgs'] destination: The destination the requests will be mirrored to.
               Structure is documented below.
        """
        if destination is not None:
            pulumi.set(__self__, "destination", destination)

    @property
    @pulumi.getter
    def destination(self) -> Optional[pulumi.Input['HttpRouteRuleActionRequestMirrorPolicyDestinationArgs']]:
        """
        The destination the requests will be mirrored to.
        Structure is documented below.
        """
        return pulumi.get(self, "destination")

    @destination.setter
    def destination(self, value: Optional[pulumi.Input['HttpRouteRuleActionRequestMirrorPolicyDestinationArgs']]):
        pulumi.set(self, "destination", value)


@pulumi.input_type
class HttpRouteRuleActionRequestMirrorPolicyDestinationArgs:
    def __init__(__self__, *,
                 service_name: Optional[pulumi.Input[str]] = None,
                 weight: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] service_name: The URL of a BackendService to route traffic to.
        :param pulumi.Input[int] weight: Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
               If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
               If weights are specified for any one service name, they need to be specified for all of them.
               If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
        """
        if service_name is not None:
            pulumi.set(__self__, "service_name", service_name)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> Optional[pulumi.Input[str]]:
        """
        The URL of a BackendService to route traffic to.
        """
        return pulumi.get(self, "service_name")

    @service_name.setter
    def service_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_name", value)

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
        If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
        If weights are specified for any one service name, they need to be specified for all of them.
        If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "weight", value)


@pulumi.input_type
class HttpRouteRuleActionResponseHeaderModifierArgs:
    def __init__(__self__, *,
                 add: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 removes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 set: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] add: Add the headers with given map where key is the name of the header, value is the value of the header.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] removes: Remove headers (matching by header names) specified in the list.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] set: Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.
        """
        if add is not None:
            pulumi.set(__self__, "add", add)
        if removes is not None:
            pulumi.set(__self__, "removes", removes)
        if set is not None:
            pulumi.set(__self__, "set", set)

    @property
    @pulumi.getter
    def add(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Add the headers with given map where key is the name of the header, value is the value of the header.
        """
        return pulumi.get(self, "add")

    @add.setter
    def add(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "add", value)

    @property
    @pulumi.getter
    def removes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Remove headers (matching by header names) specified in the list.
        """
        return pulumi.get(self, "removes")

    @removes.setter
    def removes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "removes", value)

    @property
    @pulumi.getter
    def set(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.
        """
        return pulumi.get(self, "set")

    @set.setter
    def set(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "set", value)


@pulumi.input_type
class HttpRouteRuleActionRetryPolicyArgs:
    def __init__(__self__, *,
                 num_retries: Optional[pulumi.Input[int]] = None,
                 per_try_timeout: Optional[pulumi.Input[str]] = None,
                 retry_conditions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] num_retries: Specifies the allowed number of retries.
        :param pulumi.Input[str] per_try_timeout: Specifies a non-zero timeout per retry attempt. A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
        :param pulumi.Input[Sequence[pulumi.Input[str]]] retry_conditions: Specifies one or more conditions when this retry policy applies.
        """
        if num_retries is not None:
            pulumi.set(__self__, "num_retries", num_retries)
        if per_try_timeout is not None:
            pulumi.set(__self__, "per_try_timeout", per_try_timeout)
        if retry_conditions is not None:
            pulumi.set(__self__, "retry_conditions", retry_conditions)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the allowed number of retries.
        """
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_retries", value)

    @property
    @pulumi.getter(name="perTryTimeout")
    def per_try_timeout(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies a non-zero timeout per retry attempt. A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
        """
        return pulumi.get(self, "per_try_timeout")

    @per_try_timeout.setter
    def per_try_timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "per_try_timeout", value)

    @property
    @pulumi.getter(name="retryConditions")
    def retry_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies one or more conditions when this retry policy applies.
        """
        return pulumi.get(self, "retry_conditions")

    @retry_conditions.setter
    def retry_conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "retry_conditions", value)


@pulumi.input_type
class HttpRouteRuleActionUrlRewriteArgs:
    def __init__(__self__, *,
                 host_rewrite: Optional[pulumi.Input[str]] = None,
                 path_prefix_rewrite: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_rewrite: Prior to forwarding the request to the selected destination, the requests host header is replaced by this value.
        :param pulumi.Input[str] path_prefix_rewrite: Prior to forwarding the request to the selected destination, the matching portion of the requests path is replaced by this value.
        """
        if host_rewrite is not None:
            pulumi.set(__self__, "host_rewrite", host_rewrite)
        if path_prefix_rewrite is not None:
            pulumi.set(__self__, "path_prefix_rewrite", path_prefix_rewrite)

    @property
    @pulumi.getter(name="hostRewrite")
    def host_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected destination, the requests host header is replaced by this value.
        """
        return pulumi.get(self, "host_rewrite")

    @host_rewrite.setter
    def host_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host_rewrite", value)

    @property
    @pulumi.getter(name="pathPrefixRewrite")
    def path_prefix_rewrite(self) -> Optional[pulumi.Input[str]]:
        """
        Prior to forwarding the request to the selected destination, the matching portion of the requests path is replaced by this value.
        """
        return pulumi.get(self, "path_prefix_rewrite")

    @path_prefix_rewrite.setter
    def path_prefix_rewrite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "path_prefix_rewrite", value)


@pulumi.input_type
class HttpRouteRuleMatchArgs:
    def __init__(__self__, *,
                 full_path_match: Optional[pulumi.Input[str]] = None,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchHeaderArgs']]]] = None,
                 ignore_case: Optional[pulumi.Input[bool]] = None,
                 prefix_match: Optional[pulumi.Input[str]] = None,
                 query_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchQueryParameterArgs']]]] = None,
                 regex_match: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] full_path_match: The HTTP request path value should exactly match this value.
        :param pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchHeaderArgs']]] headers: Specifies a list of HTTP request headers to match against.
               Structure is documented below.
        :param pulumi.Input[bool] ignore_case: Specifies if prefixMatch and fullPathMatch matches are case sensitive. The default value is false.
        :param pulumi.Input[str] prefix_match: The HTTP request path value must begin with specified prefixMatch. prefixMatch must begin with a /.
        :param pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchQueryParameterArgs']]] query_parameters: Specifies a list of query parameters to match against.
               Structure is documented below.
        :param pulumi.Input[str] regex_match: The HTTP request path value must satisfy the regular expression specified by regexMatch after removing any query parameters and anchor supplied with the original URL. For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax
        """
        if full_path_match is not None:
            pulumi.set(__self__, "full_path_match", full_path_match)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if ignore_case is not None:
            pulumi.set(__self__, "ignore_case", ignore_case)
        if prefix_match is not None:
            pulumi.set(__self__, "prefix_match", prefix_match)
        if query_parameters is not None:
            pulumi.set(__self__, "query_parameters", query_parameters)
        if regex_match is not None:
            pulumi.set(__self__, "regex_match", regex_match)

    @property
    @pulumi.getter(name="fullPathMatch")
    def full_path_match(self) -> Optional[pulumi.Input[str]]:
        """
        The HTTP request path value should exactly match this value.
        """
        return pulumi.get(self, "full_path_match")

    @full_path_match.setter
    def full_path_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "full_path_match", value)

    @property
    @pulumi.getter
    def headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchHeaderArgs']]]]:
        """
        Specifies a list of HTTP request headers to match against.
        Structure is documented below.
        """
        return pulumi.get(self, "headers")

    @headers.setter
    def headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchHeaderArgs']]]]):
        pulumi.set(self, "headers", value)

    @property
    @pulumi.getter(name="ignoreCase")
    def ignore_case(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies if prefixMatch and fullPathMatch matches are case sensitive. The default value is false.
        """
        return pulumi.get(self, "ignore_case")

    @ignore_case.setter
    def ignore_case(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_case", value)

    @property
    @pulumi.getter(name="prefixMatch")
    def prefix_match(self) -> Optional[pulumi.Input[str]]:
        """
        The HTTP request path value must begin with specified prefixMatch. prefixMatch must begin with a /.
        """
        return pulumi.get(self, "prefix_match")

    @prefix_match.setter
    def prefix_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_match", value)

    @property
    @pulumi.getter(name="queryParameters")
    def query_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchQueryParameterArgs']]]]:
        """
        Specifies a list of query parameters to match against.
        Structure is documented below.
        """
        return pulumi.get(self, "query_parameters")

    @query_parameters.setter
    def query_parameters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchQueryParameterArgs']]]]):
        pulumi.set(self, "query_parameters", value)

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[pulumi.Input[str]]:
        """
        The HTTP request path value must satisfy the regular expression specified by regexMatch after removing any query parameters and anchor supplied with the original URL. For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax
        """
        return pulumi.get(self, "regex_match")

    @regex_match.setter
    def regex_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "regex_match", value)


@pulumi.input_type
class HttpRouteRuleMatchHeaderArgs:
    def __init__(__self__, *,
                 exact_match: Optional[pulumi.Input[str]] = None,
                 header: Optional[pulumi.Input[str]] = None,
                 invert_match: Optional[pulumi.Input[bool]] = None,
                 prefix_match: Optional[pulumi.Input[str]] = None,
                 present_match: Optional[pulumi.Input[bool]] = None,
                 range_match: Optional[pulumi.Input['HttpRouteRuleMatchHeaderRangeMatchArgs']] = None,
                 regex_match: Optional[pulumi.Input[str]] = None,
                 suffix_match: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] exact_match: The value of the header should match exactly the content of exactMatch.
        :param pulumi.Input[str] header: The name of the HTTP header to match against.
        :param pulumi.Input[bool] invert_match: If specified, the match result will be inverted before checking. Default value is set to false.
        :param pulumi.Input[str] prefix_match: The value of the header must start with the contents of prefixMatch.
        :param pulumi.Input[bool] present_match: A header with headerName must exist. The match takes place whether or not the header has a value.
        :param pulumi.Input['HttpRouteRuleMatchHeaderRangeMatchArgs'] range_match: If specified, the rule will match if the request header value is within the range.
               Structure is documented below.
        :param pulumi.Input[str] regex_match: The value of the header must match the regular expression specified in regexMatch.
        :param pulumi.Input[str] suffix_match: The value of the header must end with the contents of suffixMatch.
        """
        if exact_match is not None:
            pulumi.set(__self__, "exact_match", exact_match)
        if header is not None:
            pulumi.set(__self__, "header", header)
        if invert_match is not None:
            pulumi.set(__self__, "invert_match", invert_match)
        if prefix_match is not None:
            pulumi.set(__self__, "prefix_match", prefix_match)
        if present_match is not None:
            pulumi.set(__self__, "present_match", present_match)
        if range_match is not None:
            pulumi.set(__self__, "range_match", range_match)
        if regex_match is not None:
            pulumi.set(__self__, "regex_match", regex_match)
        if suffix_match is not None:
            pulumi.set(__self__, "suffix_match", suffix_match)

    @property
    @pulumi.getter(name="exactMatch")
    def exact_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header should match exactly the content of exactMatch.
        """
        return pulumi.get(self, "exact_match")

    @exact_match.setter
    def exact_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "exact_match", value)

    @property
    @pulumi.getter
    def header(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the HTTP header to match against.
        """
        return pulumi.get(self, "header")

    @header.setter
    def header(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "header", value)

    @property
    @pulumi.getter(name="invertMatch")
    def invert_match(self) -> Optional[pulumi.Input[bool]]:
        """
        If specified, the match result will be inverted before checking. Default value is set to false.
        """
        return pulumi.get(self, "invert_match")

    @invert_match.setter
    def invert_match(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "invert_match", value)

    @property
    @pulumi.getter(name="prefixMatch")
    def prefix_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header must start with the contents of prefixMatch.
        """
        return pulumi.get(self, "prefix_match")

    @prefix_match.setter
    def prefix_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "prefix_match", value)

    @property
    @pulumi.getter(name="presentMatch")
    def present_match(self) -> Optional[pulumi.Input[bool]]:
        """
        A header with headerName must exist. The match takes place whether or not the header has a value.
        """
        return pulumi.get(self, "present_match")

    @present_match.setter
    def present_match(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "present_match", value)

    @property
    @pulumi.getter(name="rangeMatch")
    def range_match(self) -> Optional[pulumi.Input['HttpRouteRuleMatchHeaderRangeMatchArgs']]:
        """
        If specified, the rule will match if the request header value is within the range.
        Structure is documented below.
        """
        return pulumi.get(self, "range_match")

    @range_match.setter
    def range_match(self, value: Optional[pulumi.Input['HttpRouteRuleMatchHeaderRangeMatchArgs']]):
        pulumi.set(self, "range_match", value)

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header must match the regular expression specified in regexMatch.
        """
        return pulumi.get(self, "regex_match")

    @regex_match.setter
    def regex_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "regex_match", value)

    @property
    @pulumi.getter(name="suffixMatch")
    def suffix_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the header must end with the contents of suffixMatch.
        """
        return pulumi.get(self, "suffix_match")

    @suffix_match.setter
    def suffix_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "suffix_match", value)


@pulumi.input_type
class HttpRouteRuleMatchHeaderRangeMatchArgs:
    def __init__(__self__, *,
                 end: pulumi.Input[int],
                 start: pulumi.Input[int]):
        """
        :param pulumi.Input[int] end: End of the range (exclusive).
        :param pulumi.Input[int] start: Start of the range (inclusive).
        """
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def end(self) -> pulumi.Input[int]:
        """
        End of the range (exclusive).
        """
        return pulumi.get(self, "end")

    @end.setter
    def end(self, value: pulumi.Input[int]):
        pulumi.set(self, "end", value)

    @property
    @pulumi.getter
    def start(self) -> pulumi.Input[int]:
        """
        Start of the range (inclusive).
        """
        return pulumi.get(self, "start")

    @start.setter
    def start(self, value: pulumi.Input[int]):
        pulumi.set(self, "start", value)


@pulumi.input_type
class HttpRouteRuleMatchQueryParameterArgs:
    def __init__(__self__, *,
                 exact_match: Optional[pulumi.Input[str]] = None,
                 present_match: Optional[pulumi.Input[bool]] = None,
                 query_parameter: Optional[pulumi.Input[str]] = None,
                 regex_match: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] exact_match: The value of the query parameter must exactly match the contents of exactMatch.
        :param pulumi.Input[bool] present_match: Specifies that the QueryParameterMatcher matches if request contains query parameter, irrespective of whether the parameter has a value or not.
        :param pulumi.Input[str] query_parameter: The name of the query parameter to match.
        :param pulumi.Input[str] regex_match: The value of the query parameter must match the regular expression specified by regexMatch.For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax
        """
        if exact_match is not None:
            pulumi.set(__self__, "exact_match", exact_match)
        if present_match is not None:
            pulumi.set(__self__, "present_match", present_match)
        if query_parameter is not None:
            pulumi.set(__self__, "query_parameter", query_parameter)
        if regex_match is not None:
            pulumi.set(__self__, "regex_match", regex_match)

    @property
    @pulumi.getter(name="exactMatch")
    def exact_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the query parameter must exactly match the contents of exactMatch.
        """
        return pulumi.get(self, "exact_match")

    @exact_match.setter
    def exact_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "exact_match", value)

    @property
    @pulumi.getter(name="presentMatch")
    def present_match(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies that the QueryParameterMatcher matches if request contains query parameter, irrespective of whether the parameter has a value or not.
        """
        return pulumi.get(self, "present_match")

    @present_match.setter
    def present_match(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "present_match", value)

    @property
    @pulumi.getter(name="queryParameter")
    def query_parameter(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the query parameter to match.
        """
        return pulumi.get(self, "query_parameter")

    @query_parameter.setter
    def query_parameter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "query_parameter", value)

    @property
    @pulumi.getter(name="regexMatch")
    def regex_match(self) -> Optional[pulumi.Input[str]]:
        """
        The value of the query parameter must match the regular expression specified by regexMatch.For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax
        """
        return pulumi.get(self, "regex_match")

    @regex_match.setter
    def regex_match(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "regex_match", value)


@pulumi.input_type
class TcpRouteRuleArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['TcpRouteRuleActionArgs'],
                 matches: Optional[pulumi.Input[Sequence[pulumi.Input['TcpRouteRuleMatchArgs']]]] = None):
        """
        :param pulumi.Input['TcpRouteRuleActionArgs'] action: A detailed rule defining how to route traffic.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['TcpRouteRuleMatchArgs']]] matches: RouteMatch defines the predicate used to match requests to a given action. Multiple match types are "OR"ed for evaluation.
               If no routeMatch field is specified, this rule will unconditionally match traffic.
               Structure is documented below.
        """
        pulumi.set(__self__, "action", action)
        if matches is not None:
            pulumi.set(__self__, "matches", matches)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input['TcpRouteRuleActionArgs']:
        """
        A detailed rule defining how to route traffic.
        Structure is documented below.
        """
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: pulumi.Input['TcpRouteRuleActionArgs']):
        pulumi.set(self, "action", value)

    @property
    @pulumi.getter
    def matches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpRouteRuleMatchArgs']]]]:
        """
        RouteMatch defines the predicate used to match requests to a given action. Multiple match types are "OR"ed for evaluation.
        If no routeMatch field is specified, this rule will unconditionally match traffic.
        Structure is documented below.
        """
        return pulumi.get(self, "matches")

    @matches.setter
    def matches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpRouteRuleMatchArgs']]]]):
        pulumi.set(self, "matches", value)


@pulumi.input_type
class TcpRouteRuleActionArgs:
    def __init__(__self__, *,
                 destinations: Optional[pulumi.Input[Sequence[pulumi.Input['TcpRouteRuleActionDestinationArgs']]]] = None,
                 original_destination: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['TcpRouteRuleActionDestinationArgs']]] destinations: The destination services to which traffic should be forwarded. At least one destination service is required.
               Structure is documented below.
        :param pulumi.Input[bool] original_destination: If true, Router will use the destination IP and port of the original connection as the destination of the request.
        """
        if destinations is not None:
            pulumi.set(__self__, "destinations", destinations)
        if original_destination is not None:
            pulumi.set(__self__, "original_destination", original_destination)

    @property
    @pulumi.getter
    def destinations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TcpRouteRuleActionDestinationArgs']]]]:
        """
        The destination services to which traffic should be forwarded. At least one destination service is required.
        Structure is documented below.
        """
        return pulumi.get(self, "destinations")

    @destinations.setter
    def destinations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TcpRouteRuleActionDestinationArgs']]]]):
        pulumi.set(self, "destinations", value)

    @property
    @pulumi.getter(name="originalDestination")
    def original_destination(self) -> Optional[pulumi.Input[bool]]:
        """
        If true, Router will use the destination IP and port of the original connection as the destination of the request.
        """
        return pulumi.get(self, "original_destination")

    @original_destination.setter
    def original_destination(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "original_destination", value)


@pulumi.input_type
class TcpRouteRuleActionDestinationArgs:
    def __init__(__self__, *,
                 service_name: Optional[pulumi.Input[str]] = None,
                 weight: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] service_name: The URL of a BackendService to route traffic to.
        :param pulumi.Input[int] weight: Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
               If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
               If weights are specified for any one service name, they need to be specified for all of them.
               If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
               
               - - -
        """
        if service_name is not None:
            pulumi.set(__self__, "service_name", service_name)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> Optional[pulumi.Input[str]]:
        """
        The URL of a BackendService to route traffic to.
        """
        return pulumi.get(self, "service_name")

    @service_name.setter
    def service_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_name", value)

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
        If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
        If weights are specified for any one service name, they need to be specified for all of them.
        If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.

        - - -
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "weight", value)


@pulumi.input_type
class TcpRouteRuleMatchArgs:
    def __init__(__self__, *,
                 address: pulumi.Input[str],
                 port: pulumi.Input[str]):
        """
        :param pulumi.Input[str] address: Must be specified in the CIDR range format. A CIDR range consists of an IP Address and a prefix length to construct the subnet mask.
               By default, the prefix length is 32 (i.e. matches a single IP address). Only IPV4 addresses are supported. Examples: "10.0.0.1" - matches against this exact IP address. "10.0.0.0/8" - matches against any IP address within the 10.0.0.0 subnet and 255.255.255.0 mask. "0.0.0.0/0" - matches against any IP address'.
        :param pulumi.Input[str] port: Specifies the destination port to match against.
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def address(self) -> pulumi.Input[str]:
        """
        Must be specified in the CIDR range format. A CIDR range consists of an IP Address and a prefix length to construct the subnet mask.
        By default, the prefix length is 32 (i.e. matches a single IP address). Only IPV4 addresses are supported. Examples: "10.0.0.1" - matches against this exact IP address. "10.0.0.0/8" - matches against any IP address within the 10.0.0.0 subnet and 255.255.255.0 mask. "0.0.0.0/0" - matches against any IP address'.
        """
        return pulumi.get(self, "address")

    @address.setter
    def address(self, value: pulumi.Input[str]):
        pulumi.set(self, "address", value)

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[str]:
        """
        Specifies the destination port to match against.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[str]):
        pulumi.set(self, "port", value)


@pulumi.input_type
class TlsRouteRuleArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['TlsRouteRuleActionArgs'],
                 matches: pulumi.Input[Sequence[pulumi.Input['TlsRouteRuleMatchArgs']]]):
        """
        :param pulumi.Input['TlsRouteRuleActionArgs'] action: Required. A detailed rule defining how to route traffic.
               Structure is documented below.
        :param pulumi.Input[Sequence[pulumi.Input['TlsRouteRuleMatchArgs']]] matches: Matches define the predicate used to match requests to a given action.
               Structure is documented below.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "matches", matches)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input['TlsRouteRuleActionArgs']:
        """
        Required. A detailed rule defining how to route traffic.
        Structure is documented below.
        """
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: pulumi.Input['TlsRouteRuleActionArgs']):
        pulumi.set(self, "action", value)

    @property
    @pulumi.getter
    def matches(self) -> pulumi.Input[Sequence[pulumi.Input['TlsRouteRuleMatchArgs']]]:
        """
        Matches define the predicate used to match requests to a given action.
        Structure is documented below.
        """
        return pulumi.get(self, "matches")

    @matches.setter
    def matches(self, value: pulumi.Input[Sequence[pulumi.Input['TlsRouteRuleMatchArgs']]]):
        pulumi.set(self, "matches", value)


@pulumi.input_type
class TlsRouteRuleActionArgs:
    def __init__(__self__, *,
                 destinations: Optional[pulumi.Input[Sequence[pulumi.Input['TlsRouteRuleActionDestinationArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['TlsRouteRuleActionDestinationArgs']]] destinations: The destination to which traffic should be forwarded.
               Structure is documented below.
        """
        if destinations is not None:
            pulumi.set(__self__, "destinations", destinations)

    @property
    @pulumi.getter
    def destinations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TlsRouteRuleActionDestinationArgs']]]]:
        """
        The destination to which traffic should be forwarded.
        Structure is documented below.
        """
        return pulumi.get(self, "destinations")

    @destinations.setter
    def destinations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TlsRouteRuleActionDestinationArgs']]]]):
        pulumi.set(self, "destinations", value)


@pulumi.input_type
class TlsRouteRuleActionDestinationArgs:
    def __init__(__self__, *,
                 service_name: Optional[pulumi.Input[str]] = None,
                 weight: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] service_name: The URL of a BackendService to route traffic to.
        :param pulumi.Input[int] weight: Specifies the proportion of requests forwarded to the backend referenced by the serviceName field.
               
               - - -
        """
        if service_name is not None:
            pulumi.set(__self__, "service_name", service_name)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> Optional[pulumi.Input[str]]:
        """
        The URL of a BackendService to route traffic to.
        """
        return pulumi.get(self, "service_name")

    @service_name.setter
    def service_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_name", value)

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the proportion of requests forwarded to the backend referenced by the serviceName field.

        - - -
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "weight", value)


@pulumi.input_type
class TlsRouteRuleMatchArgs:
    def __init__(__self__, *,
                 alpns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 sni_hosts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] alpns: ALPN (Application-Layer Protocol Negotiation) to match against. Examples: "http/1.1", "h2". At least one of sniHost and alpn is required. Up to 5 alpns across all matches can be set.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] sni_hosts: SNI (server name indicator) to match against. SNI will be matched against all wildcard domains, i.e. www.example.com will be first matched against www.example.com, then *.example.com, then *.com.
               Partial wildcards are not supported, and values like *w.example.com are invalid. At least one of sniHost and alpn is required. Up to 5 sni hosts across all matches can be set.
        """
        if alpns is not None:
            pulumi.set(__self__, "alpns", alpns)
        if sni_hosts is not None:
            pulumi.set(__self__, "sni_hosts", sni_hosts)

    @property
    @pulumi.getter
    def alpns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        ALPN (Application-Layer Protocol Negotiation) to match against. Examples: "http/1.1", "h2". At least one of sniHost and alpn is required. Up to 5 alpns across all matches can be set.
        """
        return pulumi.get(self, "alpns")

    @alpns.setter
    def alpns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "alpns", value)

    @property
    @pulumi.getter(name="sniHosts")
    def sni_hosts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        SNI (server name indicator) to match against. SNI will be matched against all wildcard domains, i.e. www.example.com will be first matched against www.example.com, then *.example.com, then *.com.
        Partial wildcards are not supported, and values like *w.example.com are invalid. At least one of sniHost and alpn is required. Up to 5 sni hosts across all matches can be set.
        """
        return pulumi.get(self, "sni_hosts")

    @sni_hosts.setter
    def sni_hosts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "sni_hosts", value)


