# 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 sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities

__all__ = [
    'CustomHttpsConfigurationCustomHttpsConfigurationArgs',
    'CustomHttpsConfigurationCustomHttpsConfigurationArgsDict',
    'FirewallPolicyCustomRuleArgs',
    'FirewallPolicyCustomRuleArgsDict',
    'FirewallPolicyCustomRuleMatchConditionArgs',
    'FirewallPolicyCustomRuleMatchConditionArgsDict',
    'FirewallPolicyManagedRuleArgs',
    'FirewallPolicyManagedRuleArgsDict',
    'FirewallPolicyManagedRuleExclusionArgs',
    'FirewallPolicyManagedRuleExclusionArgsDict',
    'FirewallPolicyManagedRuleOverrideArgs',
    'FirewallPolicyManagedRuleOverrideArgsDict',
    'FirewallPolicyManagedRuleOverrideExclusionArgs',
    'FirewallPolicyManagedRuleOverrideExclusionArgsDict',
    'FirewallPolicyManagedRuleOverrideRuleArgs',
    'FirewallPolicyManagedRuleOverrideRuleArgsDict',
    'FirewallPolicyManagedRuleOverrideRuleExclusionArgs',
    'FirewallPolicyManagedRuleOverrideRuleExclusionArgsDict',
    'FrontdoorBackendPoolArgs',
    'FrontdoorBackendPoolArgsDict',
    'FrontdoorBackendPoolBackendArgs',
    'FrontdoorBackendPoolBackendArgsDict',
    'FrontdoorBackendPoolHealthProbeArgs',
    'FrontdoorBackendPoolHealthProbeArgsDict',
    'FrontdoorBackendPoolLoadBalancingArgs',
    'FrontdoorBackendPoolLoadBalancingArgsDict',
    'FrontdoorBackendPoolSettingArgs',
    'FrontdoorBackendPoolSettingArgsDict',
    'FrontdoorExplicitResourceOrderArgs',
    'FrontdoorExplicitResourceOrderArgsDict',
    'FrontdoorFrontendEndpointArgs',
    'FrontdoorFrontendEndpointArgsDict',
    'FrontdoorRoutingRuleArgs',
    'FrontdoorRoutingRuleArgsDict',
    'FrontdoorRoutingRuleForwardingConfigurationArgs',
    'FrontdoorRoutingRuleForwardingConfigurationArgsDict',
    'FrontdoorRoutingRuleRedirectConfigurationArgs',
    'FrontdoorRoutingRuleRedirectConfigurationArgsDict',
    'RulesEngineRuleArgs',
    'RulesEngineRuleArgsDict',
    'RulesEngineRuleActionArgs',
    'RulesEngineRuleActionArgsDict',
    'RulesEngineRuleActionRequestHeaderArgs',
    'RulesEngineRuleActionRequestHeaderArgsDict',
    'RulesEngineRuleActionResponseHeaderArgs',
    'RulesEngineRuleActionResponseHeaderArgsDict',
    'RulesEngineRuleMatchConditionArgs',
    'RulesEngineRuleMatchConditionArgsDict',
]

MYPY = False

if not MYPY:
    class CustomHttpsConfigurationCustomHttpsConfigurationArgsDict(TypedDict):
        azure_key_vault_certificate_secret_name: NotRequired[pulumi.Input[str]]
        """
        The name of the Key Vault secret representing the full certificate PFX.
        """
        azure_key_vault_certificate_secret_version: NotRequired[pulumi.Input[str]]
        """
        The version of the Key Vault secret representing the full certificate PFX.

        > **Note:** In order to enable the use of your own custom `HTTPS certificate` you must grant `Azure Front Door Service` access to your key vault. For instructions on how to configure your `Key Vault` correctly please refer to the [product documentation](https://docs.microsoft.com/azure/frontdoor/front-door-custom-domain-https#option-2-use-your-own-certificate).
        """
        azure_key_vault_certificate_vault_id: NotRequired[pulumi.Input[str]]
        """
        The ID of the Key Vault containing the SSL certificate.
        """
        certificate_source: NotRequired[pulumi.Input[str]]
        """
        Certificate source to encrypted `HTTPS` traffic with. Allowed values are `FrontDoor` or `AzureKeyVault`. Defaults to `FrontDoor`.

        The following attributes are only valid if `certificate_source` is set to `AzureKeyVault`:
        """
        minimum_tls_version: NotRequired[pulumi.Input[str]]
        """
        Minimum client TLS version supported.
        """
        provisioning_state: NotRequired[pulumi.Input[str]]
        provisioning_substate: NotRequired[pulumi.Input[str]]
elif False:
    CustomHttpsConfigurationCustomHttpsConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CustomHttpsConfigurationCustomHttpsConfigurationArgs:
    def __init__(__self__, *,
                 azure_key_vault_certificate_secret_name: Optional[pulumi.Input[str]] = None,
                 azure_key_vault_certificate_secret_version: Optional[pulumi.Input[str]] = None,
                 azure_key_vault_certificate_vault_id: Optional[pulumi.Input[str]] = None,
                 certificate_source: Optional[pulumi.Input[str]] = None,
                 minimum_tls_version: Optional[pulumi.Input[str]] = None,
                 provisioning_state: Optional[pulumi.Input[str]] = None,
                 provisioning_substate: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] azure_key_vault_certificate_secret_name: The name of the Key Vault secret representing the full certificate PFX.
        :param pulumi.Input[str] azure_key_vault_certificate_secret_version: The version of the Key Vault secret representing the full certificate PFX.
               
               > **Note:** In order to enable the use of your own custom `HTTPS certificate` you must grant `Azure Front Door Service` access to your key vault. For instructions on how to configure your `Key Vault` correctly please refer to the [product documentation](https://docs.microsoft.com/azure/frontdoor/front-door-custom-domain-https#option-2-use-your-own-certificate).
        :param pulumi.Input[str] azure_key_vault_certificate_vault_id: The ID of the Key Vault containing the SSL certificate.
        :param pulumi.Input[str] certificate_source: Certificate source to encrypted `HTTPS` traffic with. Allowed values are `FrontDoor` or `AzureKeyVault`. Defaults to `FrontDoor`.
               
               The following attributes are only valid if `certificate_source` is set to `AzureKeyVault`:
        :param pulumi.Input[str] minimum_tls_version: Minimum client TLS version supported.
        """
        if azure_key_vault_certificate_secret_name is not None:
            pulumi.set(__self__, "azure_key_vault_certificate_secret_name", azure_key_vault_certificate_secret_name)
        if azure_key_vault_certificate_secret_version is not None:
            pulumi.set(__self__, "azure_key_vault_certificate_secret_version", azure_key_vault_certificate_secret_version)
        if azure_key_vault_certificate_vault_id is not None:
            pulumi.set(__self__, "azure_key_vault_certificate_vault_id", azure_key_vault_certificate_vault_id)
        if certificate_source is not None:
            pulumi.set(__self__, "certificate_source", certificate_source)
        if minimum_tls_version is not None:
            pulumi.set(__self__, "minimum_tls_version", minimum_tls_version)
        if provisioning_state is not None:
            pulumi.set(__self__, "provisioning_state", provisioning_state)
        if provisioning_substate is not None:
            pulumi.set(__self__, "provisioning_substate", provisioning_substate)

    @property
    @pulumi.getter(name="azureKeyVaultCertificateSecretName")
    def azure_key_vault_certificate_secret_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the Key Vault secret representing the full certificate PFX.
        """
        return pulumi.get(self, "azure_key_vault_certificate_secret_name")

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

    @property
    @pulumi.getter(name="azureKeyVaultCertificateSecretVersion")
    def azure_key_vault_certificate_secret_version(self) -> Optional[pulumi.Input[str]]:
        """
        The version of the Key Vault secret representing the full certificate PFX.

        > **Note:** In order to enable the use of your own custom `HTTPS certificate` you must grant `Azure Front Door Service` access to your key vault. For instructions on how to configure your `Key Vault` correctly please refer to the [product documentation](https://docs.microsoft.com/azure/frontdoor/front-door-custom-domain-https#option-2-use-your-own-certificate).
        """
        return pulumi.get(self, "azure_key_vault_certificate_secret_version")

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

    @property
    @pulumi.getter(name="azureKeyVaultCertificateVaultId")
    def azure_key_vault_certificate_vault_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the Key Vault containing the SSL certificate.
        """
        return pulumi.get(self, "azure_key_vault_certificate_vault_id")

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

    @property
    @pulumi.getter(name="certificateSource")
    def certificate_source(self) -> Optional[pulumi.Input[str]]:
        """
        Certificate source to encrypted `HTTPS` traffic with. Allowed values are `FrontDoor` or `AzureKeyVault`. Defaults to `FrontDoor`.

        The following attributes are only valid if `certificate_source` is set to `AzureKeyVault`:
        """
        return pulumi.get(self, "certificate_source")

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

    @property
    @pulumi.getter(name="minimumTlsVersion")
    def minimum_tls_version(self) -> Optional[pulumi.Input[str]]:
        """
        Minimum client TLS version supported.
        """
        return pulumi.get(self, "minimum_tls_version")

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

    @property
    @pulumi.getter(name="provisioningState")
    def provisioning_state(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "provisioning_state")

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

    @property
    @pulumi.getter(name="provisioningSubstate")
    def provisioning_substate(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "provisioning_substate")

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


if not MYPY:
    class FirewallPolicyCustomRuleArgsDict(TypedDict):
        action: pulumi.Input[str]
        """
        The action to perform when the rule is matched. Possible values are `Allow`, `Block`, `Log`, or `Redirect`.
        """
        name: pulumi.Input[str]
        """
        Gets name of the resource that is unique within a policy. This name can be used to access the resource.
        """
        type: pulumi.Input[str]
        """
        The type of rule. Possible values are `MatchRule` or `RateLimitRule`.
        """
        enabled: NotRequired[pulumi.Input[bool]]
        """
        Is the rule is enabled or disabled? Defaults to `true`.
        """
        match_conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyCustomRuleMatchConditionArgsDict']]]]
        """
        One or more `match_condition` block defined below. Can support up to `10` `match_condition` blocks.
        """
        priority: NotRequired[pulumi.Input[int]]
        """
        The priority of the rule. Rules with a lower value will be evaluated before rules with a higher value. Defaults to `1`.
        """
        rate_limit_duration_in_minutes: NotRequired[pulumi.Input[int]]
        """
        The rate limit duration in minutes. Defaults to `1`.
        """
        rate_limit_threshold: NotRequired[pulumi.Input[int]]
        """
        The rate limit threshold. Defaults to `10`.
        """
elif False:
    FirewallPolicyCustomRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FirewallPolicyCustomRuleArgs:
    def __init__(__self__, *,
                 action: pulumi.Input[str],
                 name: pulumi.Input[str],
                 type: pulumi.Input[str],
                 enabled: Optional[pulumi.Input[bool]] = None,
                 match_conditions: Optional[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyCustomRuleMatchConditionArgs']]]] = None,
                 priority: Optional[pulumi.Input[int]] = None,
                 rate_limit_duration_in_minutes: Optional[pulumi.Input[int]] = None,
                 rate_limit_threshold: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] action: The action to perform when the rule is matched. Possible values are `Allow`, `Block`, `Log`, or `Redirect`.
        :param pulumi.Input[str] name: Gets name of the resource that is unique within a policy. This name can be used to access the resource.
        :param pulumi.Input[str] type: The type of rule. Possible values are `MatchRule` or `RateLimitRule`.
        :param pulumi.Input[bool] enabled: Is the rule is enabled or disabled? Defaults to `true`.
        :param pulumi.Input[Sequence[pulumi.Input['FirewallPolicyCustomRuleMatchConditionArgs']]] match_conditions: One or more `match_condition` block defined below. Can support up to `10` `match_condition` blocks.
        :param pulumi.Input[int] priority: The priority of the rule. Rules with a lower value will be evaluated before rules with a higher value. Defaults to `1`.
        :param pulumi.Input[int] rate_limit_duration_in_minutes: The rate limit duration in minutes. Defaults to `1`.
        :param pulumi.Input[int] rate_limit_threshold: The rate limit threshold. Defaults to `10`.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if match_conditions is not None:
            pulumi.set(__self__, "match_conditions", match_conditions)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if rate_limit_duration_in_minutes is not None:
            pulumi.set(__self__, "rate_limit_duration_in_minutes", rate_limit_duration_in_minutes)
        if rate_limit_threshold is not None:
            pulumi.set(__self__, "rate_limit_threshold", rate_limit_threshold)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input[str]:
        """
        The action to perform when the rule is matched. Possible values are `Allow`, `Block`, `Log`, or `Redirect`.
        """
        return pulumi.get(self, "action")

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

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Gets name of the resource that is unique within a policy. This name can be used to access the resource.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The type of rule. Possible values are `MatchRule` or `RateLimitRule`.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Is the rule is enabled or disabled? Defaults to `true`.
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter(name="matchConditions")
    def match_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyCustomRuleMatchConditionArgs']]]]:
        """
        One or more `match_condition` block defined below. Can support up to `10` `match_condition` blocks.
        """
        return pulumi.get(self, "match_conditions")

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

    @property
    @pulumi.getter
    def priority(self) -> Optional[pulumi.Input[int]]:
        """
        The priority of the rule. Rules with a lower value will be evaluated before rules with a higher value. Defaults to `1`.
        """
        return pulumi.get(self, "priority")

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

    @property
    @pulumi.getter(name="rateLimitDurationInMinutes")
    def rate_limit_duration_in_minutes(self) -> Optional[pulumi.Input[int]]:
        """
        The rate limit duration in minutes. Defaults to `1`.
        """
        return pulumi.get(self, "rate_limit_duration_in_minutes")

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

    @property
    @pulumi.getter(name="rateLimitThreshold")
    def rate_limit_threshold(self) -> Optional[pulumi.Input[int]]:
        """
        The rate limit threshold. Defaults to `10`.
        """
        return pulumi.get(self, "rate_limit_threshold")

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


if not MYPY:
    class FirewallPolicyCustomRuleMatchConditionArgsDict(TypedDict):
        match_values: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        Up to `600` possible values to match. Limit is in total across all `match_condition` blocks and `match_values` arguments. String value itself can be up to `256` characters long.
        """
        match_variable: pulumi.Input[str]
        """
        The request variable to compare with. Possible values are `Cookies`, `PostArgs`, `QueryString`, `RemoteAddr`, `RequestBody`, `RequestHeader`, `RequestMethod`, `RequestUri`, or `SocketAddr`.
        """
        operator: pulumi.Input[str]
        """
        Comparison type to use for matching with the variable value. Possible values are `Any`, `BeginsWith`, `Contains`, `EndsWith`, `Equal`, `GeoMatch`, `GreaterThan`, `GreaterThanOrEqual`, `IPMatch`, `LessThan`, `LessThanOrEqual` or `RegEx`.
        """
        negation_condition: NotRequired[pulumi.Input[bool]]
        """
        Should the result of the condition be negated.
        """
        selector: NotRequired[pulumi.Input[str]]
        """
        Match against a specific key if the `match_variable` is `QueryString`, `PostArgs`, `RequestHeader` or `Cookies`.
        """
        transforms: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Up to `5` transforms to apply. Possible values are `Lowercase`, `RemoveNulls`, `Trim`, `Uppercase`, `URLDecode` or`URLEncode`.
        """
elif False:
    FirewallPolicyCustomRuleMatchConditionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FirewallPolicyCustomRuleMatchConditionArgs:
    def __init__(__self__, *,
                 match_values: pulumi.Input[Sequence[pulumi.Input[str]]],
                 match_variable: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 negation_condition: Optional[pulumi.Input[bool]] = None,
                 selector: Optional[pulumi.Input[str]] = None,
                 transforms: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] match_values: Up to `600` possible values to match. Limit is in total across all `match_condition` blocks and `match_values` arguments. String value itself can be up to `256` characters long.
        :param pulumi.Input[str] match_variable: The request variable to compare with. Possible values are `Cookies`, `PostArgs`, `QueryString`, `RemoteAddr`, `RequestBody`, `RequestHeader`, `RequestMethod`, `RequestUri`, or `SocketAddr`.
        :param pulumi.Input[str] operator: Comparison type to use for matching with the variable value. Possible values are `Any`, `BeginsWith`, `Contains`, `EndsWith`, `Equal`, `GeoMatch`, `GreaterThan`, `GreaterThanOrEqual`, `IPMatch`, `LessThan`, `LessThanOrEqual` or `RegEx`.
        :param pulumi.Input[bool] negation_condition: Should the result of the condition be negated.
        :param pulumi.Input[str] selector: Match against a specific key if the `match_variable` is `QueryString`, `PostArgs`, `RequestHeader` or `Cookies`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] transforms: Up to `5` transforms to apply. Possible values are `Lowercase`, `RemoveNulls`, `Trim`, `Uppercase`, `URLDecode` or`URLEncode`.
        """
        pulumi.set(__self__, "match_values", match_values)
        pulumi.set(__self__, "match_variable", match_variable)
        pulumi.set(__self__, "operator", operator)
        if negation_condition is not None:
            pulumi.set(__self__, "negation_condition", negation_condition)
        if selector is not None:
            pulumi.set(__self__, "selector", selector)
        if transforms is not None:
            pulumi.set(__self__, "transforms", transforms)

    @property
    @pulumi.getter(name="matchValues")
    def match_values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        Up to `600` possible values to match. Limit is in total across all `match_condition` blocks and `match_values` arguments. String value itself can be up to `256` characters long.
        """
        return pulumi.get(self, "match_values")

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

    @property
    @pulumi.getter(name="matchVariable")
    def match_variable(self) -> pulumi.Input[str]:
        """
        The request variable to compare with. Possible values are `Cookies`, `PostArgs`, `QueryString`, `RemoteAddr`, `RequestBody`, `RequestHeader`, `RequestMethod`, `RequestUri`, or `SocketAddr`.
        """
        return pulumi.get(self, "match_variable")

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

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        """
        Comparison type to use for matching with the variable value. Possible values are `Any`, `BeginsWith`, `Contains`, `EndsWith`, `Equal`, `GeoMatch`, `GreaterThan`, `GreaterThanOrEqual`, `IPMatch`, `LessThan`, `LessThanOrEqual` or `RegEx`.
        """
        return pulumi.get(self, "operator")

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

    @property
    @pulumi.getter(name="negationCondition")
    def negation_condition(self) -> Optional[pulumi.Input[bool]]:
        """
        Should the result of the condition be negated.
        """
        return pulumi.get(self, "negation_condition")

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

    @property
    @pulumi.getter
    def selector(self) -> Optional[pulumi.Input[str]]:
        """
        Match against a specific key if the `match_variable` is `QueryString`, `PostArgs`, `RequestHeader` or `Cookies`.
        """
        return pulumi.get(self, "selector")

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

    @property
    @pulumi.getter
    def transforms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Up to `5` transforms to apply. Possible values are `Lowercase`, `RemoveNulls`, `Trim`, `Uppercase`, `URLDecode` or`URLEncode`.
        """
        return pulumi.get(self, "transforms")

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


if not MYPY:
    class FirewallPolicyManagedRuleArgsDict(TypedDict):
        type: pulumi.Input[str]
        """
        The name of the managed rule to use with this resource.
        """
        version: pulumi.Input[str]
        """
        The version on the managed rule to use with this resource.
        """
        exclusions: NotRequired[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleExclusionArgsDict']]]]
        """
        One or more `exclusion` blocks as defined below.
        """
        overrides: NotRequired[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideArgsDict']]]]
        """
        One or more `override` blocks as defined below.
        """
elif False:
    FirewallPolicyManagedRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FirewallPolicyManagedRuleArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 version: pulumi.Input[str],
                 exclusions: Optional[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleExclusionArgs']]]] = None,
                 overrides: Optional[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideArgs']]]] = None):
        """
        :param pulumi.Input[str] type: The name of the managed rule to use with this resource.
        :param pulumi.Input[str] version: The version on the managed rule to use with this resource.
        :param pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleExclusionArgs']]] exclusions: One or more `exclusion` blocks as defined below.
        :param pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideArgs']]] overrides: One or more `override` blocks as defined below.
        """
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "version", version)
        if exclusions is not None:
            pulumi.set(__self__, "exclusions", exclusions)
        if overrides is not None:
            pulumi.set(__self__, "overrides", overrides)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The name of the managed rule to use with this resource.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter
    def version(self) -> pulumi.Input[str]:
        """
        The version on the managed rule to use with this resource.
        """
        return pulumi.get(self, "version")

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

    @property
    @pulumi.getter
    def exclusions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleExclusionArgs']]]]:
        """
        One or more `exclusion` blocks as defined below.
        """
        return pulumi.get(self, "exclusions")

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

    @property
    @pulumi.getter
    def overrides(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideArgs']]]]:
        """
        One or more `override` blocks as defined below.
        """
        return pulumi.get(self, "overrides")

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


if not MYPY:
    class FirewallPolicyManagedRuleExclusionArgsDict(TypedDict):
        match_variable: pulumi.Input[str]
        """
        The variable type to be excluded. Possible values are `QueryStringArgNames`, `RequestBodyPostArgNames`, `RequestCookieNames`, `RequestHeaderNames`.
        """
        operator: pulumi.Input[str]
        """
        Comparison operator to apply to the selector when specifying which elements in the collection this exclusion applies to. Possible values are: `Equals`, `Contains`, `StartsWith`, `EndsWith`, `EqualsAny`.
        """
        selector: pulumi.Input[str]
        """
        Selector for the value in the `match_variable` attribute this exclusion applies to.
        """
elif False:
    FirewallPolicyManagedRuleExclusionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FirewallPolicyManagedRuleExclusionArgs:
    def __init__(__self__, *,
                 match_variable: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 selector: pulumi.Input[str]):
        """
        :param pulumi.Input[str] match_variable: The variable type to be excluded. Possible values are `QueryStringArgNames`, `RequestBodyPostArgNames`, `RequestCookieNames`, `RequestHeaderNames`.
        :param pulumi.Input[str] operator: Comparison operator to apply to the selector when specifying which elements in the collection this exclusion applies to. Possible values are: `Equals`, `Contains`, `StartsWith`, `EndsWith`, `EqualsAny`.
        :param pulumi.Input[str] selector: Selector for the value in the `match_variable` attribute this exclusion applies to.
        """
        pulumi.set(__self__, "match_variable", match_variable)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "selector", selector)

    @property
    @pulumi.getter(name="matchVariable")
    def match_variable(self) -> pulumi.Input[str]:
        """
        The variable type to be excluded. Possible values are `QueryStringArgNames`, `RequestBodyPostArgNames`, `RequestCookieNames`, `RequestHeaderNames`.
        """
        return pulumi.get(self, "match_variable")

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

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        """
        Comparison operator to apply to the selector when specifying which elements in the collection this exclusion applies to. Possible values are: `Equals`, `Contains`, `StartsWith`, `EndsWith`, `EqualsAny`.
        """
        return pulumi.get(self, "operator")

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

    @property
    @pulumi.getter
    def selector(self) -> pulumi.Input[str]:
        """
        Selector for the value in the `match_variable` attribute this exclusion applies to.
        """
        return pulumi.get(self, "selector")

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


if not MYPY:
    class FirewallPolicyManagedRuleOverrideArgsDict(TypedDict):
        rule_group_name: pulumi.Input[str]
        """
        The managed rule group to override.
        """
        exclusions: NotRequired[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideExclusionArgsDict']]]]
        """
        One or more `exclusion` blocks as defined below.
        """
        rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideRuleArgsDict']]]]
        """
        One or more `rule` blocks as defined below. If none are specified, all of the rules in the group will be disabled.
        """
elif False:
    FirewallPolicyManagedRuleOverrideArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FirewallPolicyManagedRuleOverrideArgs:
    def __init__(__self__, *,
                 rule_group_name: pulumi.Input[str],
                 exclusions: Optional[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideExclusionArgs']]]] = None,
                 rules: Optional[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideRuleArgs']]]] = None):
        """
        :param pulumi.Input[str] rule_group_name: The managed rule group to override.
        :param pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideExclusionArgs']]] exclusions: One or more `exclusion` blocks as defined below.
        :param pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideRuleArgs']]] rules: One or more `rule` blocks as defined below. If none are specified, all of the rules in the group will be disabled.
        """
        pulumi.set(__self__, "rule_group_name", rule_group_name)
        if exclusions is not None:
            pulumi.set(__self__, "exclusions", exclusions)
        if rules is not None:
            pulumi.set(__self__, "rules", rules)

    @property
    @pulumi.getter(name="ruleGroupName")
    def rule_group_name(self) -> pulumi.Input[str]:
        """
        The managed rule group to override.
        """
        return pulumi.get(self, "rule_group_name")

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

    @property
    @pulumi.getter
    def exclusions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideExclusionArgs']]]]:
        """
        One or more `exclusion` blocks as defined below.
        """
        return pulumi.get(self, "exclusions")

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

    @property
    @pulumi.getter
    def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideRuleArgs']]]]:
        """
        One or more `rule` blocks as defined below. If none are specified, all of the rules in the group will be disabled.
        """
        return pulumi.get(self, "rules")

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


if not MYPY:
    class FirewallPolicyManagedRuleOverrideExclusionArgsDict(TypedDict):
        match_variable: pulumi.Input[str]
        """
        The variable type to be excluded. Possible values are `QueryStringArgNames`, `RequestBodyPostArgNames`, `RequestCookieNames`, `RequestHeaderNames`.
        """
        operator: pulumi.Input[str]
        """
        Comparison operator to apply to the selector when specifying which elements in the collection this exclusion applies to. Possible values are: `Equals`, `Contains`, `StartsWith`, `EndsWith`, `EqualsAny`.
        """
        selector: pulumi.Input[str]
        """
        Selector for the value in the `match_variable` attribute this exclusion applies to.
        """
elif False:
    FirewallPolicyManagedRuleOverrideExclusionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FirewallPolicyManagedRuleOverrideExclusionArgs:
    def __init__(__self__, *,
                 match_variable: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 selector: pulumi.Input[str]):
        """
        :param pulumi.Input[str] match_variable: The variable type to be excluded. Possible values are `QueryStringArgNames`, `RequestBodyPostArgNames`, `RequestCookieNames`, `RequestHeaderNames`.
        :param pulumi.Input[str] operator: Comparison operator to apply to the selector when specifying which elements in the collection this exclusion applies to. Possible values are: `Equals`, `Contains`, `StartsWith`, `EndsWith`, `EqualsAny`.
        :param pulumi.Input[str] selector: Selector for the value in the `match_variable` attribute this exclusion applies to.
        """
        pulumi.set(__self__, "match_variable", match_variable)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "selector", selector)

    @property
    @pulumi.getter(name="matchVariable")
    def match_variable(self) -> pulumi.Input[str]:
        """
        The variable type to be excluded. Possible values are `QueryStringArgNames`, `RequestBodyPostArgNames`, `RequestCookieNames`, `RequestHeaderNames`.
        """
        return pulumi.get(self, "match_variable")

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

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        """
        Comparison operator to apply to the selector when specifying which elements in the collection this exclusion applies to. Possible values are: `Equals`, `Contains`, `StartsWith`, `EndsWith`, `EqualsAny`.
        """
        return pulumi.get(self, "operator")

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

    @property
    @pulumi.getter
    def selector(self) -> pulumi.Input[str]:
        """
        Selector for the value in the `match_variable` attribute this exclusion applies to.
        """
        return pulumi.get(self, "selector")

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


if not MYPY:
    class FirewallPolicyManagedRuleOverrideRuleArgsDict(TypedDict):
        action: pulumi.Input[str]
        """
        The action to be applied when the rule matches. Possible values are `Allow`, `Block`, `Log`, or `Redirect`.
        """
        rule_id: pulumi.Input[str]
        """
        Identifier for the managed rule.
        """
        enabled: NotRequired[pulumi.Input[bool]]
        """
        Is the managed rule override enabled or disabled. Defaults to `false`
        """
        exclusions: NotRequired[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideRuleExclusionArgsDict']]]]
        """
        One or more `exclusion` blocks as defined below.
        """
elif False:
    FirewallPolicyManagedRuleOverrideRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FirewallPolicyManagedRuleOverrideRuleArgs:
    def __init__(__self__, *,
                 action: pulumi.Input[str],
                 rule_id: pulumi.Input[str],
                 enabled: Optional[pulumi.Input[bool]] = None,
                 exclusions: Optional[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideRuleExclusionArgs']]]] = None):
        """
        :param pulumi.Input[str] action: The action to be applied when the rule matches. Possible values are `Allow`, `Block`, `Log`, or `Redirect`.
        :param pulumi.Input[str] rule_id: Identifier for the managed rule.
        :param pulumi.Input[bool] enabled: Is the managed rule override enabled or disabled. Defaults to `false`
        :param pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideRuleExclusionArgs']]] exclusions: One or more `exclusion` blocks as defined below.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "rule_id", rule_id)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if exclusions is not None:
            pulumi.set(__self__, "exclusions", exclusions)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input[str]:
        """
        The action to be applied when the rule matches. Possible values are `Allow`, `Block`, `Log`, or `Redirect`.
        """
        return pulumi.get(self, "action")

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

    @property
    @pulumi.getter(name="ruleId")
    def rule_id(self) -> pulumi.Input[str]:
        """
        Identifier for the managed rule.
        """
        return pulumi.get(self, "rule_id")

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

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Is the managed rule override enabled or disabled. Defaults to `false`
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter
    def exclusions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['FirewallPolicyManagedRuleOverrideRuleExclusionArgs']]]]:
        """
        One or more `exclusion` blocks as defined below.
        """
        return pulumi.get(self, "exclusions")

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


if not MYPY:
    class FirewallPolicyManagedRuleOverrideRuleExclusionArgsDict(TypedDict):
        match_variable: pulumi.Input[str]
        """
        The variable type to be excluded. Possible values are `QueryStringArgNames`, `RequestBodyPostArgNames`, `RequestCookieNames`, `RequestHeaderNames`.
        """
        operator: pulumi.Input[str]
        """
        Comparison operator to apply to the selector when specifying which elements in the collection this exclusion applies to. Possible values are: `Equals`, `Contains`, `StartsWith`, `EndsWith`, `EqualsAny`.
        """
        selector: pulumi.Input[str]
        """
        Selector for the value in the `match_variable` attribute this exclusion applies to.
        """
elif False:
    FirewallPolicyManagedRuleOverrideRuleExclusionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FirewallPolicyManagedRuleOverrideRuleExclusionArgs:
    def __init__(__self__, *,
                 match_variable: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 selector: pulumi.Input[str]):
        """
        :param pulumi.Input[str] match_variable: The variable type to be excluded. Possible values are `QueryStringArgNames`, `RequestBodyPostArgNames`, `RequestCookieNames`, `RequestHeaderNames`.
        :param pulumi.Input[str] operator: Comparison operator to apply to the selector when specifying which elements in the collection this exclusion applies to. Possible values are: `Equals`, `Contains`, `StartsWith`, `EndsWith`, `EqualsAny`.
        :param pulumi.Input[str] selector: Selector for the value in the `match_variable` attribute this exclusion applies to.
        """
        pulumi.set(__self__, "match_variable", match_variable)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "selector", selector)

    @property
    @pulumi.getter(name="matchVariable")
    def match_variable(self) -> pulumi.Input[str]:
        """
        The variable type to be excluded. Possible values are `QueryStringArgNames`, `RequestBodyPostArgNames`, `RequestCookieNames`, `RequestHeaderNames`.
        """
        return pulumi.get(self, "match_variable")

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

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        """
        Comparison operator to apply to the selector when specifying which elements in the collection this exclusion applies to. Possible values are: `Equals`, `Contains`, `StartsWith`, `EndsWith`, `EqualsAny`.
        """
        return pulumi.get(self, "operator")

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

    @property
    @pulumi.getter
    def selector(self) -> pulumi.Input[str]:
        """
        Selector for the value in the `match_variable` attribute this exclusion applies to.
        """
        return pulumi.get(self, "selector")

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


if not MYPY:
    class FrontdoorBackendPoolArgsDict(TypedDict):
        backends: pulumi.Input[Sequence[pulumi.Input['FrontdoorBackendPoolBackendArgsDict']]]
        """
        A `backend` block as defined below.
        """
        health_probe_name: pulumi.Input[str]
        """
        Specifies the name of the `backend_pool_health_probe` block within this resource to use for this `Backend Pool`.
        """
        load_balancing_name: pulumi.Input[str]
        """
        Specifies the name of the `backend_pool_load_balancing` block within this resource to use for this `Backend Pool`.
        """
        name: pulumi.Input[str]
        """
        Specifies the name of the Backend Pool.
        """
        id: NotRequired[pulumi.Input[str]]
        """
        The ID of the FrontDoor.
        """
elif False:
    FrontdoorBackendPoolArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FrontdoorBackendPoolArgs:
    def __init__(__self__, *,
                 backends: pulumi.Input[Sequence[pulumi.Input['FrontdoorBackendPoolBackendArgs']]],
                 health_probe_name: pulumi.Input[str],
                 load_balancing_name: pulumi.Input[str],
                 name: pulumi.Input[str],
                 id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['FrontdoorBackendPoolBackendArgs']]] backends: A `backend` block as defined below.
        :param pulumi.Input[str] health_probe_name: Specifies the name of the `backend_pool_health_probe` block within this resource to use for this `Backend Pool`.
        :param pulumi.Input[str] load_balancing_name: Specifies the name of the `backend_pool_load_balancing` block within this resource to use for this `Backend Pool`.
        :param pulumi.Input[str] name: Specifies the name of the Backend Pool.
        :param pulumi.Input[str] id: The ID of the FrontDoor.
        """
        pulumi.set(__self__, "backends", backends)
        pulumi.set(__self__, "health_probe_name", health_probe_name)
        pulumi.set(__self__, "load_balancing_name", load_balancing_name)
        pulumi.set(__self__, "name", name)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def backends(self) -> pulumi.Input[Sequence[pulumi.Input['FrontdoorBackendPoolBackendArgs']]]:
        """
        A `backend` block as defined below.
        """
        return pulumi.get(self, "backends")

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

    @property
    @pulumi.getter(name="healthProbeName")
    def health_probe_name(self) -> pulumi.Input[str]:
        """
        Specifies the name of the `backend_pool_health_probe` block within this resource to use for this `Backend Pool`.
        """
        return pulumi.get(self, "health_probe_name")

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

    @property
    @pulumi.getter(name="loadBalancingName")
    def load_balancing_name(self) -> pulumi.Input[str]:
        """
        Specifies the name of the `backend_pool_load_balancing` block within this resource to use for this `Backend Pool`.
        """
        return pulumi.get(self, "load_balancing_name")

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

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Specifies the name of the Backend Pool.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the FrontDoor.
        """
        return pulumi.get(self, "id")

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


if not MYPY:
    class FrontdoorBackendPoolBackendArgsDict(TypedDict):
        address: pulumi.Input[str]
        """
        Location of the backend (IP address or FQDN)
        """
        host_header: pulumi.Input[str]
        """
        The value to use as the host header sent to the backend.
        """
        http_port: pulumi.Input[int]
        """
        The HTTP TCP port number. Possible values are between `1` - `65535`.
        """
        https_port: pulumi.Input[int]
        """
        The HTTPS TCP port number. Possible values are between `1` - `65535`.
        """
        enabled: NotRequired[pulumi.Input[bool]]
        """
        Specifies if the backend is enabled or not. Valid options are `true` or `false`. Defaults to `true`.
        """
        priority: NotRequired[pulumi.Input[int]]
        """
        Priority to use for load balancing. Higher priorities will not be used for load balancing if any lower priority backend is healthy. Defaults to `1`.
        """
        weight: NotRequired[pulumi.Input[int]]
        """
        Weight of this endpoint for load balancing purposes. Defaults to `50`.
        """
elif False:
    FrontdoorBackendPoolBackendArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FrontdoorBackendPoolBackendArgs:
    def __init__(__self__, *,
                 address: pulumi.Input[str],
                 host_header: pulumi.Input[str],
                 http_port: pulumi.Input[int],
                 https_port: pulumi.Input[int],
                 enabled: Optional[pulumi.Input[bool]] = None,
                 priority: Optional[pulumi.Input[int]] = None,
                 weight: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] address: Location of the backend (IP address or FQDN)
        :param pulumi.Input[str] host_header: The value to use as the host header sent to the backend.
        :param pulumi.Input[int] http_port: The HTTP TCP port number. Possible values are between `1` - `65535`.
        :param pulumi.Input[int] https_port: The HTTPS TCP port number. Possible values are between `1` - `65535`.
        :param pulumi.Input[bool] enabled: Specifies if the backend is enabled or not. Valid options are `true` or `false`. Defaults to `true`.
        :param pulumi.Input[int] priority: Priority to use for load balancing. Higher priorities will not be used for load balancing if any lower priority backend is healthy. Defaults to `1`.
        :param pulumi.Input[int] weight: Weight of this endpoint for load balancing purposes. Defaults to `50`.
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "host_header", host_header)
        pulumi.set(__self__, "http_port", http_port)
        pulumi.set(__self__, "https_port", https_port)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def address(self) -> pulumi.Input[str]:
        """
        Location of the backend (IP address or FQDN)
        """
        return pulumi.get(self, "address")

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

    @property
    @pulumi.getter(name="hostHeader")
    def host_header(self) -> pulumi.Input[str]:
        """
        The value to use as the host header sent to the backend.
        """
        return pulumi.get(self, "host_header")

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

    @property
    @pulumi.getter(name="httpPort")
    def http_port(self) -> pulumi.Input[int]:
        """
        The HTTP TCP port number. Possible values are between `1` - `65535`.
        """
        return pulumi.get(self, "http_port")

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

    @property
    @pulumi.getter(name="httpsPort")
    def https_port(self) -> pulumi.Input[int]:
        """
        The HTTPS TCP port number. Possible values are between `1` - `65535`.
        """
        return pulumi.get(self, "https_port")

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

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies if the backend is enabled or not. Valid options are `true` or `false`. Defaults to `true`.
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter
    def priority(self) -> Optional[pulumi.Input[int]]:
        """
        Priority to use for load balancing. Higher priorities will not be used for load balancing if any lower priority backend is healthy. Defaults to `1`.
        """
        return pulumi.get(self, "priority")

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

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[int]]:
        """
        Weight of this endpoint for load balancing purposes. Defaults to `50`.
        """
        return pulumi.get(self, "weight")

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


if not MYPY:
    class FrontdoorBackendPoolHealthProbeArgsDict(TypedDict):
        name: pulumi.Input[str]
        """
        Specifies the name of the Health Probe.
        """
        enabled: NotRequired[pulumi.Input[bool]]
        """
        Is this health probe enabled? Defaults to `true`.
        """
        id: NotRequired[pulumi.Input[str]]
        """
        The ID of the FrontDoor.
        """
        interval_in_seconds: NotRequired[pulumi.Input[int]]
        """
        The number of seconds between each Health Probe. Defaults to `120`.
        """
        path: NotRequired[pulumi.Input[str]]
        """
        The path to use for the Health Probe. Default is `/`.
        """
        probe_method: NotRequired[pulumi.Input[str]]
        """
        Specifies HTTP method the health probe uses when querying the backend pool instances. Possible values include: `GET` and `HEAD`. Defaults to `GET`.

        > **NOTE:** Use the `HEAD` method if you do not need to check the response body of your health probe.
        """
        protocol: NotRequired[pulumi.Input[str]]
        """
        Protocol scheme to use for the Health Probe. Possible values are `Http` and `Https`. Defaults to `Http`.
        """
elif False:
    FrontdoorBackendPoolHealthProbeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FrontdoorBackendPoolHealthProbeArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 enabled: Optional[pulumi.Input[bool]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 interval_in_seconds: Optional[pulumi.Input[int]] = None,
                 path: Optional[pulumi.Input[str]] = None,
                 probe_method: Optional[pulumi.Input[str]] = None,
                 protocol: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: Specifies the name of the Health Probe.
        :param pulumi.Input[bool] enabled: Is this health probe enabled? Defaults to `true`.
        :param pulumi.Input[str] id: The ID of the FrontDoor.
        :param pulumi.Input[int] interval_in_seconds: The number of seconds between each Health Probe. Defaults to `120`.
        :param pulumi.Input[str] path: The path to use for the Health Probe. Default is `/`.
        :param pulumi.Input[str] probe_method: Specifies HTTP method the health probe uses when querying the backend pool instances. Possible values include: `GET` and `HEAD`. Defaults to `GET`.
               
               > **NOTE:** Use the `HEAD` method if you do not need to check the response body of your health probe.
        :param pulumi.Input[str] protocol: Protocol scheme to use for the Health Probe. Possible values are `Http` and `Https`. Defaults to `Http`.
        """
        pulumi.set(__self__, "name", name)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if interval_in_seconds is not None:
            pulumi.set(__self__, "interval_in_seconds", interval_in_seconds)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if probe_method is not None:
            pulumi.set(__self__, "probe_method", probe_method)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Specifies the name of the Health Probe.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Is this health probe enabled? Defaults to `true`.
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the FrontDoor.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="intervalInSeconds")
    def interval_in_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        The number of seconds between each Health Probe. Defaults to `120`.
        """
        return pulumi.get(self, "interval_in_seconds")

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

    @property
    @pulumi.getter
    def path(self) -> Optional[pulumi.Input[str]]:
        """
        The path to use for the Health Probe. Default is `/`.
        """
        return pulumi.get(self, "path")

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

    @property
    @pulumi.getter(name="probeMethod")
    def probe_method(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies HTTP method the health probe uses when querying the backend pool instances. Possible values include: `GET` and `HEAD`. Defaults to `GET`.

        > **NOTE:** Use the `HEAD` method if you do not need to check the response body of your health probe.
        """
        return pulumi.get(self, "probe_method")

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

    @property
    @pulumi.getter
    def protocol(self) -> Optional[pulumi.Input[str]]:
        """
        Protocol scheme to use for the Health Probe. Possible values are `Http` and `Https`. Defaults to `Http`.
        """
        return pulumi.get(self, "protocol")

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


if not MYPY:
    class FrontdoorBackendPoolLoadBalancingArgsDict(TypedDict):
        name: pulumi.Input[str]
        """
        Specifies the name of the Load Balancer.
        """
        additional_latency_milliseconds: NotRequired[pulumi.Input[int]]
        """
        The additional latency in milliseconds for probes to fall into the lowest latency bucket. Defaults to `0`.
        """
        id: NotRequired[pulumi.Input[str]]
        """
        The ID of the FrontDoor.
        """
        sample_size: NotRequired[pulumi.Input[int]]
        """
        The number of samples to consider for load balancing decisions. Defaults to `4`.
        """
        successful_samples_required: NotRequired[pulumi.Input[int]]
        """
        The number of samples within the sample period that must succeed. Defaults to `2`.
        """
elif False:
    FrontdoorBackendPoolLoadBalancingArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FrontdoorBackendPoolLoadBalancingArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 additional_latency_milliseconds: Optional[pulumi.Input[int]] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 sample_size: Optional[pulumi.Input[int]] = None,
                 successful_samples_required: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] name: Specifies the name of the Load Balancer.
        :param pulumi.Input[int] additional_latency_milliseconds: The additional latency in milliseconds for probes to fall into the lowest latency bucket. Defaults to `0`.
        :param pulumi.Input[str] id: The ID of the FrontDoor.
        :param pulumi.Input[int] sample_size: The number of samples to consider for load balancing decisions. Defaults to `4`.
        :param pulumi.Input[int] successful_samples_required: The number of samples within the sample period that must succeed. Defaults to `2`.
        """
        pulumi.set(__self__, "name", name)
        if additional_latency_milliseconds is not None:
            pulumi.set(__self__, "additional_latency_milliseconds", additional_latency_milliseconds)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if sample_size is not None:
            pulumi.set(__self__, "sample_size", sample_size)
        if successful_samples_required is not None:
            pulumi.set(__self__, "successful_samples_required", successful_samples_required)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Specifies the name of the Load Balancer.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="additionalLatencyMilliseconds")
    def additional_latency_milliseconds(self) -> Optional[pulumi.Input[int]]:
        """
        The additional latency in milliseconds for probes to fall into the lowest latency bucket. Defaults to `0`.
        """
        return pulumi.get(self, "additional_latency_milliseconds")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the FrontDoor.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="sampleSize")
    def sample_size(self) -> Optional[pulumi.Input[int]]:
        """
        The number of samples to consider for load balancing decisions. Defaults to `4`.
        """
        return pulumi.get(self, "sample_size")

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

    @property
    @pulumi.getter(name="successfulSamplesRequired")
    def successful_samples_required(self) -> Optional[pulumi.Input[int]]:
        """
        The number of samples within the sample period that must succeed. Defaults to `2`.
        """
        return pulumi.get(self, "successful_samples_required")

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


if not MYPY:
    class FrontdoorBackendPoolSettingArgsDict(TypedDict):
        enforce_backend_pools_certificate_name_check: pulumi.Input[bool]
        """
        Enforce certificate name check on `HTTPS` requests to all backend pools, this setting will have no effect on `HTTP` requests. Permitted values are `true` or `false`.

        > **NOTE:** `backend_pools_send_receive_timeout_seconds` and `enforce_backend_pools_certificate_name_check` apply to all backend pools.
        """
        backend_pools_send_receive_timeout_seconds: NotRequired[pulumi.Input[int]]
        """
        Specifies the send and receive timeout on forwarding request to the backend. When the timeout is reached, the request fails and returns. Possible values are between `0` - `240`. Defaults to `60`.
        """
elif False:
    FrontdoorBackendPoolSettingArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FrontdoorBackendPoolSettingArgs:
    def __init__(__self__, *,
                 enforce_backend_pools_certificate_name_check: pulumi.Input[bool],
                 backend_pools_send_receive_timeout_seconds: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] enforce_backend_pools_certificate_name_check: Enforce certificate name check on `HTTPS` requests to all backend pools, this setting will have no effect on `HTTP` requests. Permitted values are `true` or `false`.
               
               > **NOTE:** `backend_pools_send_receive_timeout_seconds` and `enforce_backend_pools_certificate_name_check` apply to all backend pools.
        :param pulumi.Input[int] backend_pools_send_receive_timeout_seconds: Specifies the send and receive timeout on forwarding request to the backend. When the timeout is reached, the request fails and returns. Possible values are between `0` - `240`. Defaults to `60`.
        """
        pulumi.set(__self__, "enforce_backend_pools_certificate_name_check", enforce_backend_pools_certificate_name_check)
        if backend_pools_send_receive_timeout_seconds is not None:
            pulumi.set(__self__, "backend_pools_send_receive_timeout_seconds", backend_pools_send_receive_timeout_seconds)

    @property
    @pulumi.getter(name="enforceBackendPoolsCertificateNameCheck")
    def enforce_backend_pools_certificate_name_check(self) -> pulumi.Input[bool]:
        """
        Enforce certificate name check on `HTTPS` requests to all backend pools, this setting will have no effect on `HTTP` requests. Permitted values are `true` or `false`.

        > **NOTE:** `backend_pools_send_receive_timeout_seconds` and `enforce_backend_pools_certificate_name_check` apply to all backend pools.
        """
        return pulumi.get(self, "enforce_backend_pools_certificate_name_check")

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

    @property
    @pulumi.getter(name="backendPoolsSendReceiveTimeoutSeconds")
    def backend_pools_send_receive_timeout_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the send and receive timeout on forwarding request to the backend. When the timeout is reached, the request fails and returns. Possible values are between `0` - `240`. Defaults to `60`.
        """
        return pulumi.get(self, "backend_pools_send_receive_timeout_seconds")

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


if not MYPY:
    class FrontdoorExplicitResourceOrderArgsDict(TypedDict):
        backend_pool_health_probe_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        backend_pool_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        backend_pool_load_balancing_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        frontend_endpoint_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        routing_rule_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
elif False:
    FrontdoorExplicitResourceOrderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FrontdoorExplicitResourceOrderArgs:
    def __init__(__self__, *,
                 backend_pool_health_probe_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 backend_pool_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 backend_pool_load_balancing_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 frontend_endpoint_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 routing_rule_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if backend_pool_health_probe_ids is not None:
            pulumi.set(__self__, "backend_pool_health_probe_ids", backend_pool_health_probe_ids)
        if backend_pool_ids is not None:
            pulumi.set(__self__, "backend_pool_ids", backend_pool_ids)
        if backend_pool_load_balancing_ids is not None:
            pulumi.set(__self__, "backend_pool_load_balancing_ids", backend_pool_load_balancing_ids)
        if frontend_endpoint_ids is not None:
            pulumi.set(__self__, "frontend_endpoint_ids", frontend_endpoint_ids)
        if routing_rule_ids is not None:
            pulumi.set(__self__, "routing_rule_ids", routing_rule_ids)

    @property
    @pulumi.getter(name="backendPoolHealthProbeIds")
    def backend_pool_health_probe_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "backend_pool_health_probe_ids")

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

    @property
    @pulumi.getter(name="backendPoolIds")
    def backend_pool_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "backend_pool_ids")

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

    @property
    @pulumi.getter(name="backendPoolLoadBalancingIds")
    def backend_pool_load_balancing_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "backend_pool_load_balancing_ids")

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

    @property
    @pulumi.getter(name="frontendEndpointIds")
    def frontend_endpoint_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "frontend_endpoint_ids")

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

    @property
    @pulumi.getter(name="routingRuleIds")
    def routing_rule_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "routing_rule_ids")

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


if not MYPY:
    class FrontdoorFrontendEndpointArgsDict(TypedDict):
        host_name: pulumi.Input[str]
        """
        Specifies the host name of the `frontend_endpoint`. Must be a domain name. In order to use a name.azurefd.net domain, the name value must match the Front Door name.
        """
        name: pulumi.Input[str]
        """
        Specifies the name of the `frontend_endpoint`.
        """
        id: NotRequired[pulumi.Input[str]]
        """
        The ID of the FrontDoor.
        """
        session_affinity_enabled: NotRequired[pulumi.Input[bool]]
        """
        Whether to allow session affinity on this host. Valid options are `true` or `false` Defaults to `false`.
        """
        session_affinity_ttl_seconds: NotRequired[pulumi.Input[int]]
        """
        The TTL to use in seconds for session affinity, if applicable. Defaults to `0`.
        """
        web_application_firewall_policy_link_id: NotRequired[pulumi.Input[str]]
        """
        Defines the Web Application Firewall policy `ID` for each host.
        """
elif False:
    FrontdoorFrontendEndpointArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FrontdoorFrontendEndpointArgs:
    def __init__(__self__, *,
                 host_name: pulumi.Input[str],
                 name: pulumi.Input[str],
                 id: Optional[pulumi.Input[str]] = None,
                 session_affinity_enabled: Optional[pulumi.Input[bool]] = None,
                 session_affinity_ttl_seconds: Optional[pulumi.Input[int]] = None,
                 web_application_firewall_policy_link_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host_name: Specifies the host name of the `frontend_endpoint`. Must be a domain name. In order to use a name.azurefd.net domain, the name value must match the Front Door name.
        :param pulumi.Input[str] name: Specifies the name of the `frontend_endpoint`.
        :param pulumi.Input[str] id: The ID of the FrontDoor.
        :param pulumi.Input[bool] session_affinity_enabled: Whether to allow session affinity on this host. Valid options are `true` or `false` Defaults to `false`.
        :param pulumi.Input[int] session_affinity_ttl_seconds: The TTL to use in seconds for session affinity, if applicable. Defaults to `0`.
        :param pulumi.Input[str] web_application_firewall_policy_link_id: Defines the Web Application Firewall policy `ID` for each host.
        """
        pulumi.set(__self__, "host_name", host_name)
        pulumi.set(__self__, "name", name)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if session_affinity_enabled is not None:
            pulumi.set(__self__, "session_affinity_enabled", session_affinity_enabled)
        if session_affinity_ttl_seconds is not None:
            pulumi.set(__self__, "session_affinity_ttl_seconds", session_affinity_ttl_seconds)
        if web_application_firewall_policy_link_id is not None:
            pulumi.set(__self__, "web_application_firewall_policy_link_id", web_application_firewall_policy_link_id)

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> pulumi.Input[str]:
        """
        Specifies the host name of the `frontend_endpoint`. Must be a domain name. In order to use a name.azurefd.net domain, the name value must match the Front Door name.
        """
        return pulumi.get(self, "host_name")

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

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Specifies the name of the `frontend_endpoint`.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the FrontDoor.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="sessionAffinityEnabled")
    def session_affinity_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to allow session affinity on this host. Valid options are `true` or `false` Defaults to `false`.
        """
        return pulumi.get(self, "session_affinity_enabled")

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

    @property
    @pulumi.getter(name="sessionAffinityTtlSeconds")
    def session_affinity_ttl_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        The TTL to use in seconds for session affinity, if applicable. Defaults to `0`.
        """
        return pulumi.get(self, "session_affinity_ttl_seconds")

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

    @property
    @pulumi.getter(name="webApplicationFirewallPolicyLinkId")
    def web_application_firewall_policy_link_id(self) -> Optional[pulumi.Input[str]]:
        """
        Defines the Web Application Firewall policy `ID` for each host.
        """
        return pulumi.get(self, "web_application_firewall_policy_link_id")

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


if not MYPY:
    class FrontdoorRoutingRuleArgsDict(TypedDict):
        accepted_protocols: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        Protocol schemes to match for the Backend Routing Rule. Possible values are `Http` and `Https`.
        """
        frontend_endpoints: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        The names of the `frontend_endpoint` blocks within this resource to associate with this `routing_rule`.
        """
        name: pulumi.Input[str]
        """
        Specifies the name of the Routing Rule.
        """
        patterns_to_matches: pulumi.Input[Sequence[pulumi.Input[str]]]
        """
        The route patterns for the Backend Routing Rule.
        """
        enabled: NotRequired[pulumi.Input[bool]]
        """
        `Enable` or `Disable` use of this Backend Routing Rule. Permitted values are `true` or `false`. Defaults to `true`.
        """
        forwarding_configuration: NotRequired[pulumi.Input['FrontdoorRoutingRuleForwardingConfigurationArgsDict']]
        """
        A `forwarding_configuration` block as defined below.
        """
        id: NotRequired[pulumi.Input[str]]
        """
        The ID of the FrontDoor.
        """
        redirect_configuration: NotRequired[pulumi.Input['FrontdoorRoutingRuleRedirectConfigurationArgsDict']]
        """
        A `redirect_configuration` block as defined below.
        """
elif False:
    FrontdoorRoutingRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FrontdoorRoutingRuleArgs:
    def __init__(__self__, *,
                 accepted_protocols: pulumi.Input[Sequence[pulumi.Input[str]]],
                 frontend_endpoints: pulumi.Input[Sequence[pulumi.Input[str]]],
                 name: pulumi.Input[str],
                 patterns_to_matches: pulumi.Input[Sequence[pulumi.Input[str]]],
                 enabled: Optional[pulumi.Input[bool]] = None,
                 forwarding_configuration: Optional[pulumi.Input['FrontdoorRoutingRuleForwardingConfigurationArgs']] = None,
                 id: Optional[pulumi.Input[str]] = None,
                 redirect_configuration: Optional[pulumi.Input['FrontdoorRoutingRuleRedirectConfigurationArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] accepted_protocols: Protocol schemes to match for the Backend Routing Rule. Possible values are `Http` and `Https`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] frontend_endpoints: The names of the `frontend_endpoint` blocks within this resource to associate with this `routing_rule`.
        :param pulumi.Input[str] name: Specifies the name of the Routing Rule.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] patterns_to_matches: The route patterns for the Backend Routing Rule.
        :param pulumi.Input[bool] enabled: `Enable` or `Disable` use of this Backend Routing Rule. Permitted values are `true` or `false`. Defaults to `true`.
        :param pulumi.Input['FrontdoorRoutingRuleForwardingConfigurationArgs'] forwarding_configuration: A `forwarding_configuration` block as defined below.
        :param pulumi.Input[str] id: The ID of the FrontDoor.
        :param pulumi.Input['FrontdoorRoutingRuleRedirectConfigurationArgs'] redirect_configuration: A `redirect_configuration` block as defined below.
        """
        pulumi.set(__self__, "accepted_protocols", accepted_protocols)
        pulumi.set(__self__, "frontend_endpoints", frontend_endpoints)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "patterns_to_matches", patterns_to_matches)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if forwarding_configuration is not None:
            pulumi.set(__self__, "forwarding_configuration", forwarding_configuration)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if redirect_configuration is not None:
            pulumi.set(__self__, "redirect_configuration", redirect_configuration)

    @property
    @pulumi.getter(name="acceptedProtocols")
    def accepted_protocols(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        Protocol schemes to match for the Backend Routing Rule. Possible values are `Http` and `Https`.
        """
        return pulumi.get(self, "accepted_protocols")

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

    @property
    @pulumi.getter(name="frontendEndpoints")
    def frontend_endpoints(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The names of the `frontend_endpoint` blocks within this resource to associate with this `routing_rule`.
        """
        return pulumi.get(self, "frontend_endpoints")

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

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Specifies the name of the Routing Rule.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="patternsToMatches")
    def patterns_to_matches(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The route patterns for the Backend Routing Rule.
        """
        return pulumi.get(self, "patterns_to_matches")

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

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        `Enable` or `Disable` use of this Backend Routing Rule. Permitted values are `true` or `false`. Defaults to `true`.
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter(name="forwardingConfiguration")
    def forwarding_configuration(self) -> Optional[pulumi.Input['FrontdoorRoutingRuleForwardingConfigurationArgs']]:
        """
        A `forwarding_configuration` block as defined below.
        """
        return pulumi.get(self, "forwarding_configuration")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the FrontDoor.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="redirectConfiguration")
    def redirect_configuration(self) -> Optional[pulumi.Input['FrontdoorRoutingRuleRedirectConfigurationArgs']]:
        """
        A `redirect_configuration` block as defined below.
        """
        return pulumi.get(self, "redirect_configuration")

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


if not MYPY:
    class FrontdoorRoutingRuleForwardingConfigurationArgsDict(TypedDict):
        backend_pool_name: pulumi.Input[str]
        """
        Specifies the name of the Backend Pool to forward the incoming traffic to.
        """
        cache_duration: NotRequired[pulumi.Input[str]]
        """
        Specify the minimum caching duration (in ISO8601 notation e.g. `P1DT2H` for 1 day and 2 hours). Needs to be greater than 0 and smaller than 365 days. `cache_duration` works only in combination with `cache_enabled` set to `true`.
        """
        cache_enabled: NotRequired[pulumi.Input[bool]]
        """
        Specifies whether to Enable caching or not. Valid options are `true` or `false`. Defaults to `false`.
        """
        cache_query_parameter_strip_directive: NotRequired[pulumi.Input[str]]
        """
        Defines cache behaviour in relation to query string parameters. Valid options are `StripAll`, `StripAllExcept`, `StripOnly` or `StripNone`. Defaults to `StripAll`.
        """
        cache_query_parameters: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Specify query parameters (array). Works only in combination with `cache_query_parameter_strip_directive` set to `StripAllExcept` or `StripOnly`.
        """
        cache_use_dynamic_compression: NotRequired[pulumi.Input[bool]]
        """
        Whether to use dynamic compression when caching. Valid options are `true` or `false`. Defaults to `false`.
        """
        custom_forwarding_path: NotRequired[pulumi.Input[str]]
        """
        Path to use when constructing the request to forward to the backend. This functions as a URL Rewrite. Default behaviour preserves the URL path.
        """
        forwarding_protocol: NotRequired[pulumi.Input[str]]
        """
        Protocol to use when redirecting. Valid options are `HttpOnly`, `HttpsOnly`, or `MatchRequest`. Defaults to `HttpsOnly`.
        """
elif False:
    FrontdoorRoutingRuleForwardingConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FrontdoorRoutingRuleForwardingConfigurationArgs:
    def __init__(__self__, *,
                 backend_pool_name: pulumi.Input[str],
                 cache_duration: Optional[pulumi.Input[str]] = None,
                 cache_enabled: Optional[pulumi.Input[bool]] = None,
                 cache_query_parameter_strip_directive: Optional[pulumi.Input[str]] = None,
                 cache_query_parameters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 cache_use_dynamic_compression: Optional[pulumi.Input[bool]] = None,
                 custom_forwarding_path: Optional[pulumi.Input[str]] = None,
                 forwarding_protocol: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] backend_pool_name: Specifies the name of the Backend Pool to forward the incoming traffic to.
        :param pulumi.Input[str] cache_duration: Specify the minimum caching duration (in ISO8601 notation e.g. `P1DT2H` for 1 day and 2 hours). Needs to be greater than 0 and smaller than 365 days. `cache_duration` works only in combination with `cache_enabled` set to `true`.
        :param pulumi.Input[bool] cache_enabled: Specifies whether to Enable caching or not. Valid options are `true` or `false`. Defaults to `false`.
        :param pulumi.Input[str] cache_query_parameter_strip_directive: Defines cache behaviour in relation to query string parameters. Valid options are `StripAll`, `StripAllExcept`, `StripOnly` or `StripNone`. Defaults to `StripAll`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] cache_query_parameters: Specify query parameters (array). Works only in combination with `cache_query_parameter_strip_directive` set to `StripAllExcept` or `StripOnly`.
        :param pulumi.Input[bool] cache_use_dynamic_compression: Whether to use dynamic compression when caching. Valid options are `true` or `false`. Defaults to `false`.
        :param pulumi.Input[str] custom_forwarding_path: Path to use when constructing the request to forward to the backend. This functions as a URL Rewrite. Default behaviour preserves the URL path.
        :param pulumi.Input[str] forwarding_protocol: Protocol to use when redirecting. Valid options are `HttpOnly`, `HttpsOnly`, or `MatchRequest`. Defaults to `HttpsOnly`.
        """
        pulumi.set(__self__, "backend_pool_name", backend_pool_name)
        if cache_duration is not None:
            pulumi.set(__self__, "cache_duration", cache_duration)
        if cache_enabled is not None:
            pulumi.set(__self__, "cache_enabled", cache_enabled)
        if cache_query_parameter_strip_directive is not None:
            pulumi.set(__self__, "cache_query_parameter_strip_directive", cache_query_parameter_strip_directive)
        if cache_query_parameters is not None:
            pulumi.set(__self__, "cache_query_parameters", cache_query_parameters)
        if cache_use_dynamic_compression is not None:
            pulumi.set(__self__, "cache_use_dynamic_compression", cache_use_dynamic_compression)
        if custom_forwarding_path is not None:
            pulumi.set(__self__, "custom_forwarding_path", custom_forwarding_path)
        if forwarding_protocol is not None:
            pulumi.set(__self__, "forwarding_protocol", forwarding_protocol)

    @property
    @pulumi.getter(name="backendPoolName")
    def backend_pool_name(self) -> pulumi.Input[str]:
        """
        Specifies the name of the Backend Pool to forward the incoming traffic to.
        """
        return pulumi.get(self, "backend_pool_name")

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

    @property
    @pulumi.getter(name="cacheDuration")
    def cache_duration(self) -> Optional[pulumi.Input[str]]:
        """
        Specify the minimum caching duration (in ISO8601 notation e.g. `P1DT2H` for 1 day and 2 hours). Needs to be greater than 0 and smaller than 365 days. `cache_duration` works only in combination with `cache_enabled` set to `true`.
        """
        return pulumi.get(self, "cache_duration")

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

    @property
    @pulumi.getter(name="cacheEnabled")
    def cache_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether to Enable caching or not. Valid options are `true` or `false`. Defaults to `false`.
        """
        return pulumi.get(self, "cache_enabled")

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

    @property
    @pulumi.getter(name="cacheQueryParameterStripDirective")
    def cache_query_parameter_strip_directive(self) -> Optional[pulumi.Input[str]]:
        """
        Defines cache behaviour in relation to query string parameters. Valid options are `StripAll`, `StripAllExcept`, `StripOnly` or `StripNone`. Defaults to `StripAll`.
        """
        return pulumi.get(self, "cache_query_parameter_strip_directive")

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

    @property
    @pulumi.getter(name="cacheQueryParameters")
    def cache_query_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specify query parameters (array). Works only in combination with `cache_query_parameter_strip_directive` set to `StripAllExcept` or `StripOnly`.
        """
        return pulumi.get(self, "cache_query_parameters")

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

    @property
    @pulumi.getter(name="cacheUseDynamicCompression")
    def cache_use_dynamic_compression(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to use dynamic compression when caching. Valid options are `true` or `false`. Defaults to `false`.
        """
        return pulumi.get(self, "cache_use_dynamic_compression")

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

    @property
    @pulumi.getter(name="customForwardingPath")
    def custom_forwarding_path(self) -> Optional[pulumi.Input[str]]:
        """
        Path to use when constructing the request to forward to the backend. This functions as a URL Rewrite. Default behaviour preserves the URL path.
        """
        return pulumi.get(self, "custom_forwarding_path")

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

    @property
    @pulumi.getter(name="forwardingProtocol")
    def forwarding_protocol(self) -> Optional[pulumi.Input[str]]:
        """
        Protocol to use when redirecting. Valid options are `HttpOnly`, `HttpsOnly`, or `MatchRequest`. Defaults to `HttpsOnly`.
        """
        return pulumi.get(self, "forwarding_protocol")

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


if not MYPY:
    class FrontdoorRoutingRuleRedirectConfigurationArgsDict(TypedDict):
        redirect_protocol: pulumi.Input[str]
        """
        Protocol to use when redirecting. Valid options are `HttpOnly`, `HttpsOnly`, or `MatchRequest`.
        """
        redirect_type: pulumi.Input[str]
        """
        Status code for the redirect. Valida options are `Moved`, `Found`, `TemporaryRedirect`, `PermanentRedirect`.
        """
        custom_fragment: NotRequired[pulumi.Input[str]]
        """
        The destination fragment in the portion of URL after '#'. Set this to add a fragment to the redirect URL.
        """
        custom_host: NotRequired[pulumi.Input[str]]
        """
        Set this to change the URL for the redirection.
        """
        custom_path: NotRequired[pulumi.Input[str]]
        """
        The path to retain as per the incoming request, or update in the URL for the redirection.
        """
        custom_query_string: NotRequired[pulumi.Input[str]]
        """
        Replace any existing query string from the incoming request URL.
        """
elif False:
    FrontdoorRoutingRuleRedirectConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FrontdoorRoutingRuleRedirectConfigurationArgs:
    def __init__(__self__, *,
                 redirect_protocol: pulumi.Input[str],
                 redirect_type: pulumi.Input[str],
                 custom_fragment: Optional[pulumi.Input[str]] = None,
                 custom_host: Optional[pulumi.Input[str]] = None,
                 custom_path: Optional[pulumi.Input[str]] = None,
                 custom_query_string: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] redirect_protocol: Protocol to use when redirecting. Valid options are `HttpOnly`, `HttpsOnly`, or `MatchRequest`.
        :param pulumi.Input[str] redirect_type: Status code for the redirect. Valida options are `Moved`, `Found`, `TemporaryRedirect`, `PermanentRedirect`.
        :param pulumi.Input[str] custom_fragment: The destination fragment in the portion of URL after '#'. Set this to add a fragment to the redirect URL.
        :param pulumi.Input[str] custom_host: Set this to change the URL for the redirection.
        :param pulumi.Input[str] custom_path: The path to retain as per the incoming request, or update in the URL for the redirection.
        :param pulumi.Input[str] custom_query_string: Replace any existing query string from the incoming request URL.
        """
        pulumi.set(__self__, "redirect_protocol", redirect_protocol)
        pulumi.set(__self__, "redirect_type", redirect_type)
        if custom_fragment is not None:
            pulumi.set(__self__, "custom_fragment", custom_fragment)
        if custom_host is not None:
            pulumi.set(__self__, "custom_host", custom_host)
        if custom_path is not None:
            pulumi.set(__self__, "custom_path", custom_path)
        if custom_query_string is not None:
            pulumi.set(__self__, "custom_query_string", custom_query_string)

    @property
    @pulumi.getter(name="redirectProtocol")
    def redirect_protocol(self) -> pulumi.Input[str]:
        """
        Protocol to use when redirecting. Valid options are `HttpOnly`, `HttpsOnly`, or `MatchRequest`.
        """
        return pulumi.get(self, "redirect_protocol")

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

    @property
    @pulumi.getter(name="redirectType")
    def redirect_type(self) -> pulumi.Input[str]:
        """
        Status code for the redirect. Valida options are `Moved`, `Found`, `TemporaryRedirect`, `PermanentRedirect`.
        """
        return pulumi.get(self, "redirect_type")

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

    @property
    @pulumi.getter(name="customFragment")
    def custom_fragment(self) -> Optional[pulumi.Input[str]]:
        """
        The destination fragment in the portion of URL after '#'. Set this to add a fragment to the redirect URL.
        """
        return pulumi.get(self, "custom_fragment")

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

    @property
    @pulumi.getter(name="customHost")
    def custom_host(self) -> Optional[pulumi.Input[str]]:
        """
        Set this to change the URL for the redirection.
        """
        return pulumi.get(self, "custom_host")

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

    @property
    @pulumi.getter(name="customPath")
    def custom_path(self) -> Optional[pulumi.Input[str]]:
        """
        The path to retain as per the incoming request, or update in the URL for the redirection.
        """
        return pulumi.get(self, "custom_path")

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

    @property
    @pulumi.getter(name="customQueryString")
    def custom_query_string(self) -> Optional[pulumi.Input[str]]:
        """
        Replace any existing query string from the incoming request URL.
        """
        return pulumi.get(self, "custom_query_string")

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


if not MYPY:
    class RulesEngineRuleArgsDict(TypedDict):
        name: pulumi.Input[str]
        """
        The name of the rule.
        """
        priority: pulumi.Input[int]
        """
        Priority of the rule, must be unique per rules engine definition.
        """
        action: NotRequired[pulumi.Input['RulesEngineRuleActionArgsDict']]
        """
        An `action` block as defined below.
        """
        match_conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input['RulesEngineRuleMatchConditionArgsDict']]]]
        """
        One or more `match_condition` block as defined below.
        """
elif False:
    RulesEngineRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RulesEngineRuleArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 priority: pulumi.Input[int],
                 action: Optional[pulumi.Input['RulesEngineRuleActionArgs']] = None,
                 match_conditions: Optional[pulumi.Input[Sequence[pulumi.Input['RulesEngineRuleMatchConditionArgs']]]] = None):
        """
        :param pulumi.Input[str] name: The name of the rule.
        :param pulumi.Input[int] priority: Priority of the rule, must be unique per rules engine definition.
        :param pulumi.Input['RulesEngineRuleActionArgs'] action: An `action` block as defined below.
        :param pulumi.Input[Sequence[pulumi.Input['RulesEngineRuleMatchConditionArgs']]] match_conditions: One or more `match_condition` block as defined below.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "priority", priority)
        if action is not None:
            pulumi.set(__self__, "action", action)
        if match_conditions is not None:
            pulumi.set(__self__, "match_conditions", match_conditions)

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

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

    @property
    @pulumi.getter
    def priority(self) -> pulumi.Input[int]:
        """
        Priority of the rule, must be unique per rules engine definition.
        """
        return pulumi.get(self, "priority")

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

    @property
    @pulumi.getter
    def action(self) -> Optional[pulumi.Input['RulesEngineRuleActionArgs']]:
        """
        An `action` block as defined below.
        """
        return pulumi.get(self, "action")

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

    @property
    @pulumi.getter(name="matchConditions")
    def match_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RulesEngineRuleMatchConditionArgs']]]]:
        """
        One or more `match_condition` block as defined below.
        """
        return pulumi.get(self, "match_conditions")

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


if not MYPY:
    class RulesEngineRuleActionArgsDict(TypedDict):
        request_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['RulesEngineRuleActionRequestHeaderArgsDict']]]]
        """
        A `request_header` block as defined below.
        """
        response_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['RulesEngineRuleActionResponseHeaderArgsDict']]]]
        """
        A `response_header` block as defined below.
        """
elif False:
    RulesEngineRuleActionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RulesEngineRuleActionArgs:
    def __init__(__self__, *,
                 request_headers: Optional[pulumi.Input[Sequence[pulumi.Input['RulesEngineRuleActionRequestHeaderArgs']]]] = None,
                 response_headers: Optional[pulumi.Input[Sequence[pulumi.Input['RulesEngineRuleActionResponseHeaderArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['RulesEngineRuleActionRequestHeaderArgs']]] request_headers: A `request_header` block as defined below.
        :param pulumi.Input[Sequence[pulumi.Input['RulesEngineRuleActionResponseHeaderArgs']]] response_headers: A `response_header` block as defined below.
        """
        if request_headers is not None:
            pulumi.set(__self__, "request_headers", request_headers)
        if response_headers is not None:
            pulumi.set(__self__, "response_headers", response_headers)

    @property
    @pulumi.getter(name="requestHeaders")
    def request_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RulesEngineRuleActionRequestHeaderArgs']]]]:
        """
        A `request_header` block as defined below.
        """
        return pulumi.get(self, "request_headers")

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

    @property
    @pulumi.getter(name="responseHeaders")
    def response_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RulesEngineRuleActionResponseHeaderArgs']]]]:
        """
        A `response_header` block as defined below.
        """
        return pulumi.get(self, "response_headers")

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


if not MYPY:
    class RulesEngineRuleActionRequestHeaderArgsDict(TypedDict):
        header_action_type: NotRequired[pulumi.Input[str]]
        """
        can be set to `Overwrite`, `Append` or `Delete`.
        """
        header_name: NotRequired[pulumi.Input[str]]
        """
        header name (string).
        """
        value: NotRequired[pulumi.Input[str]]
        """
        value name (string).
        """
elif False:
    RulesEngineRuleActionRequestHeaderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RulesEngineRuleActionRequestHeaderArgs:
    def __init__(__self__, *,
                 header_action_type: Optional[pulumi.Input[str]] = None,
                 header_name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] header_action_type: can be set to `Overwrite`, `Append` or `Delete`.
        :param pulumi.Input[str] header_name: header name (string).
        :param pulumi.Input[str] value: value name (string).
        """
        if header_action_type is not None:
            pulumi.set(__self__, "header_action_type", header_action_type)
        if header_name is not None:
            pulumi.set(__self__, "header_name", header_name)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="headerActionType")
    def header_action_type(self) -> Optional[pulumi.Input[str]]:
        """
        can be set to `Overwrite`, `Append` or `Delete`.
        """
        return pulumi.get(self, "header_action_type")

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

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

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

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        value name (string).
        """
        return pulumi.get(self, "value")

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


if not MYPY:
    class RulesEngineRuleActionResponseHeaderArgsDict(TypedDict):
        header_action_type: NotRequired[pulumi.Input[str]]
        """
        can be set to `Overwrite`, `Append` or `Delete`.
        """
        header_name: NotRequired[pulumi.Input[str]]
        """
        header name (string).
        """
        value: NotRequired[pulumi.Input[str]]
        """
        value name (string).
        """
elif False:
    RulesEngineRuleActionResponseHeaderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RulesEngineRuleActionResponseHeaderArgs:
    def __init__(__self__, *,
                 header_action_type: Optional[pulumi.Input[str]] = None,
                 header_name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] header_action_type: can be set to `Overwrite`, `Append` or `Delete`.
        :param pulumi.Input[str] header_name: header name (string).
        :param pulumi.Input[str] value: value name (string).
        """
        if header_action_type is not None:
            pulumi.set(__self__, "header_action_type", header_action_type)
        if header_name is not None:
            pulumi.set(__self__, "header_name", header_name)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="headerActionType")
    def header_action_type(self) -> Optional[pulumi.Input[str]]:
        """
        can be set to `Overwrite`, `Append` or `Delete`.
        """
        return pulumi.get(self, "header_action_type")

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

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

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

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        value name (string).
        """
        return pulumi.get(self, "value")

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


if not MYPY:
    class RulesEngineRuleMatchConditionArgsDict(TypedDict):
        operator: pulumi.Input[str]
        """
        can be set to `Any`, `IPMatch`, `GeoMatch`, `Equal`, `Contains`, `LessThan`, `GreaterThan`, `LessThanOrEqual`, `GreaterThanOrEqual`, `BeginsWith` or `EndsWith`
        """
        negate_condition: NotRequired[pulumi.Input[bool]]
        """
        can be set to `true` or `false` to negate the given condition. Defaults to `false`.
        """
        selector: NotRequired[pulumi.Input[str]]
        """
        match against a specific key when `variable` is set to `PostArgs` or `RequestHeader`. It cannot be used with `QueryString` and `RequestMethod`.
        """
        transforms: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        can be set to one or more values out of `Lowercase`, `RemoveNulls`, `Trim`, `Uppercase`, `UrlDecode` and `UrlEncode`
        """
        values: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        (array) can contain one or more strings.
        """
        variable: NotRequired[pulumi.Input[str]]
        """
        can be set to `IsMobile`, `RemoteAddr`, `RequestMethod`, `QueryString`, `PostArgs`, `RequestURI`, `RequestPath`, `RequestFilename`, `RequestFilenameExtension`,`RequestHeader`,`RequestBody` or `RequestScheme`.
        """
elif False:
    RulesEngineRuleMatchConditionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RulesEngineRuleMatchConditionArgs:
    def __init__(__self__, *,
                 operator: pulumi.Input[str],
                 negate_condition: Optional[pulumi.Input[bool]] = None,
                 selector: Optional[pulumi.Input[str]] = None,
                 transforms: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 variable: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] operator: can be set to `Any`, `IPMatch`, `GeoMatch`, `Equal`, `Contains`, `LessThan`, `GreaterThan`, `LessThanOrEqual`, `GreaterThanOrEqual`, `BeginsWith` or `EndsWith`
        :param pulumi.Input[bool] negate_condition: can be set to `true` or `false` to negate the given condition. Defaults to `false`.
        :param pulumi.Input[str] selector: match against a specific key when `variable` is set to `PostArgs` or `RequestHeader`. It cannot be used with `QueryString` and `RequestMethod`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] transforms: can be set to one or more values out of `Lowercase`, `RemoveNulls`, `Trim`, `Uppercase`, `UrlDecode` and `UrlEncode`
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: (array) can contain one or more strings.
        :param pulumi.Input[str] variable: can be set to `IsMobile`, `RemoteAddr`, `RequestMethod`, `QueryString`, `PostArgs`, `RequestURI`, `RequestPath`, `RequestFilename`, `RequestFilenameExtension`,`RequestHeader`,`RequestBody` or `RequestScheme`.
        """
        pulumi.set(__self__, "operator", operator)
        if negate_condition is not None:
            pulumi.set(__self__, "negate_condition", negate_condition)
        if selector is not None:
            pulumi.set(__self__, "selector", selector)
        if transforms is not None:
            pulumi.set(__self__, "transforms", transforms)
        if values is not None:
            pulumi.set(__self__, "values", values)
        if variable is not None:
            pulumi.set(__self__, "variable", variable)

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        """
        can be set to `Any`, `IPMatch`, `GeoMatch`, `Equal`, `Contains`, `LessThan`, `GreaterThan`, `LessThanOrEqual`, `GreaterThanOrEqual`, `BeginsWith` or `EndsWith`
        """
        return pulumi.get(self, "operator")

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

    @property
    @pulumi.getter(name="negateCondition")
    def negate_condition(self) -> Optional[pulumi.Input[bool]]:
        """
        can be set to `true` or `false` to negate the given condition. Defaults to `false`.
        """
        return pulumi.get(self, "negate_condition")

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

    @property
    @pulumi.getter
    def selector(self) -> Optional[pulumi.Input[str]]:
        """
        match against a specific key when `variable` is set to `PostArgs` or `RequestHeader`. It cannot be used with `QueryString` and `RequestMethod`.
        """
        return pulumi.get(self, "selector")

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

    @property
    @pulumi.getter
    def transforms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        can be set to one or more values out of `Lowercase`, `RemoveNulls`, `Trim`, `Uppercase`, `UrlDecode` and `UrlEncode`
        """
        return pulumi.get(self, "transforms")

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

    @property
    @pulumi.getter
    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        (array) can contain one or more strings.
        """
        return pulumi.get(self, "values")

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

    @property
    @pulumi.getter
    def variable(self) -> Optional[pulumi.Input[str]]:
        """
        can be set to `IsMobile`, `RemoteAddr`, `RequestMethod`, `QueryString`, `PostArgs`, `RequestURI`, `RequestPath`, `RequestFilename`, `RequestFilenameExtension`,`RequestHeader`,`RequestBody` or `RequestScheme`.
        """
        return pulumi.get(self, "variable")

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


