# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Dict, List, Mapping, Optional, Tuple, Union
from .. import _utilities, _tables
from . import outputs

__all__ = [
    'ApplicationGatewayAuthenticationCertificate',
    'ApplicationGatewayAutoscaleConfiguration',
    'ApplicationGatewayBackendAddressPool',
    'ApplicationGatewayBackendHttpSetting',
    'ApplicationGatewayBackendHttpSettingAuthenticationCertificate',
    'ApplicationGatewayBackendHttpSettingConnectionDraining',
    'ApplicationGatewayCustomErrorConfiguration',
    'ApplicationGatewayFrontendIpConfiguration',
    'ApplicationGatewayFrontendPort',
    'ApplicationGatewayGatewayIpConfiguration',
    'ApplicationGatewayHttpListener',
    'ApplicationGatewayHttpListenerCustomErrorConfiguration',
    'ApplicationGatewayIdentity',
    'ApplicationGatewayProbe',
    'ApplicationGatewayProbeMatch',
    'ApplicationGatewayRedirectConfiguration',
    'ApplicationGatewayRequestRoutingRule',
    'ApplicationGatewayRewriteRuleSet',
    'ApplicationGatewayRewriteRuleSetRewriteRule',
    'ApplicationGatewayRewriteRuleSetRewriteRuleCondition',
    'ApplicationGatewayRewriteRuleSetRewriteRuleRequestHeaderConfiguration',
    'ApplicationGatewayRewriteRuleSetRewriteRuleResponseHeaderConfiguration',
    'ApplicationGatewaySku',
    'ApplicationGatewaySslCertificate',
    'ApplicationGatewaySslPolicy',
    'ApplicationGatewayTrustedRootCertificate',
    'ApplicationGatewayUrlPathMap',
    'ApplicationGatewayUrlPathMapPathRule',
    'ApplicationGatewayWafConfiguration',
    'ApplicationGatewayWafConfigurationDisabledRuleGroup',
    'ApplicationGatewayWafConfigurationExclusion',
    'ExpressRouteCircuitPeeringMicrosoftPeeringConfig',
    'ExpressRouteCircuitSku',
    'FirewallApplicationRuleCollectionRule',
    'FirewallApplicationRuleCollectionRuleProtocol',
    'FirewallIpConfiguration',
    'FirewallManagementIpConfiguration',
    'FirewallNatRuleCollectionRule',
    'FirewallNetworkRuleCollectionRule',
    'LocalNetworkGatewayBgpSettings',
    'NetworkConnectionMonitorDestination',
    'NetworkConnectionMonitorSource',
    'NetworkInterfaceIpConfiguration',
    'NetworkPacketCaptureFilter',
    'NetworkPacketCaptureStorageLocation',
    'NetworkSecurityGroupSecurityRule',
    'NetworkWatcherFlowLogRetentionPolicy',
    'NetworkWatcherFlowLogTrafficAnalytics',
    'PacketCaptureFilter',
    'PacketCaptureStorageLocation',
    'PointToPointVpnGatewayConnectionConfiguration',
    'PointToPointVpnGatewayConnectionConfigurationVpnClientAddressPool',
    'ProfileContainerNetworkInterface',
    'ProfileContainerNetworkInterfaceIpConfiguration',
    'RouteFilterRule',
    'RouteTableRoute',
    'SubnetDelegation',
    'SubnetDelegationServiceDelegation',
    'TrafficManagerEndpointCustomHeader',
    'TrafficManagerEndpointSubnet',
    'TrafficManagerProfileDnsConfig',
    'TrafficManagerProfileMonitorConfig',
    'TrafficManagerProfileMonitorConfigCustomHeader',
    'VirtualHubRoute',
    'VirtualNetworkDdosProtectionPlan',
    'VirtualNetworkGatewayBgpSettings',
    'VirtualNetworkGatewayConnectionIpsecPolicy',
    'VirtualNetworkGatewayConnectionTrafficSelectorPolicy',
    'VirtualNetworkGatewayIpConfiguration',
    'VirtualNetworkGatewayVpnClientConfiguration',
    'VirtualNetworkGatewayVpnClientConfigurationRevokedCertificate',
    'VirtualNetworkGatewayVpnClientConfigurationRootCertificate',
    'VirtualNetworkSubnet',
    'VpnGatewayBgpSetting',
    'VpnServerConfigurationAzureActiveDirectoryAuthentication',
    'VpnServerConfigurationClientRevokedCertificate',
    'VpnServerConfigurationClientRootCertificate',
    'VpnServerConfigurationIpsecPolicy',
    'VpnServerConfigurationRadiusServer',
    'VpnServerConfigurationRadiusServerClientRootCertificate',
    'VpnServerConfigurationRadiusServerServerRootCertificate',
    'GetExpressRouteCircuitPeeringResult',
    'GetExpressRouteCircuitServiceProviderPropertyResult',
    'GetExpressRouteCircuitSkuResult',
    'GetFirewallIpConfigurationResult',
    'GetGatewayConnectionIpsecPolicyResult',
    'GetGatewayConnectionTrafficSelectorPolicyResult',
    'GetNetworkInterfaceIpConfigurationResult',
    'GetNetworkSecurityGroupSecurityRuleResult',
    'GetPublicIPsPublicIpResult',
    'GetRouteFilterRuleResult',
    'GetRouteTableRouteResult',
    'GetVirtualNetworkGatewayBgpSettingResult',
    'GetVirtualNetworkGatewayIpConfigurationResult',
    'GetVirtualNetworkGatewayVpnClientConfigurationResult',
    'GetVirtualNetworkGatewayVpnClientConfigurationRevokedCertificateResult',
    'GetVirtualNetworkGatewayVpnClientConfigurationRootCertificateResult',
]

@pulumi.output_type
class ApplicationGatewayAuthenticationCertificate(dict):
    def __init__(__self__, *,
                 data: str,
                 name: str,
                 id: Optional[str] = None):
        """
        :param str data: The contents of the Authentication Certificate which should be used.
        :param str name: The name of the Authentication Certificate.
        :param str id: The ID of the Rewrite Rule Set
        """
        pulumi.set(__self__, "data", data)
        pulumi.set(__self__, "name", name)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def data(self) -> str:
        """
        The contents of the Authentication Certificate which should be used.
        """
        return pulumi.get(self, "data")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Authentication Certificate.
        """
        return pulumi.get(self, "name")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayAutoscaleConfiguration(dict):
    def __init__(__self__, *,
                 min_capacity: float,
                 max_capacity: Optional[float] = None):
        """
        :param float min_capacity: Minimum capacity for autoscaling. Accepted values are in the range `0` to `100`.
        :param float max_capacity: Maximum capacity for autoscaling. Accepted values are in the range `2` to `125`.
        """
        pulumi.set(__self__, "min_capacity", min_capacity)
        if max_capacity is not None:
            pulumi.set(__self__, "max_capacity", max_capacity)

    @property
    @pulumi.getter(name="minCapacity")
    def min_capacity(self) -> float:
        """
        Minimum capacity for autoscaling. Accepted values are in the range `0` to `100`.
        """
        return pulumi.get(self, "min_capacity")

    @property
    @pulumi.getter(name="maxCapacity")
    def max_capacity(self) -> Optional[float]:
        """
        Maximum capacity for autoscaling. Accepted values are in the range `2` to `125`.
        """
        return pulumi.get(self, "max_capacity")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayBackendAddressPool(dict):
    def __init__(__self__, *,
                 name: str,
                 fqdns: Optional[List[str]] = None,
                 id: Optional[str] = None,
                 ip_addresses: Optional[List[str]] = None):
        """
        :param str name: The name of the Backend Address Pool.
        :param List[str] fqdns: A list of FQDN's which should be part of the Backend Address Pool.
        :param str id: The ID of the Rewrite Rule Set
        :param List[str] ip_addresses: A list of IP Addresses which should be part of the Backend Address Pool.
        """
        pulumi.set(__self__, "name", name)
        if fqdns is not None:
            pulumi.set(__self__, "fqdns", fqdns)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ip_addresses is not None:
            pulumi.set(__self__, "ip_addresses", ip_addresses)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Backend Address Pool.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def fqdns(self) -> Optional[List[str]]:
        """
        A list of FQDN's which should be part of the Backend Address Pool.
        """
        return pulumi.get(self, "fqdns")

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

    @property
    @pulumi.getter(name="ipAddresses")
    def ip_addresses(self) -> Optional[List[str]]:
        """
        A list of IP Addresses which should be part of the Backend Address Pool.
        """
        return pulumi.get(self, "ip_addresses")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayBackendHttpSetting(dict):
    def __init__(__self__, *,
                 cookie_based_affinity: str,
                 name: str,
                 port: float,
                 protocol: str,
                 affinity_cookie_name: Optional[str] = None,
                 authentication_certificates: Optional[List['outputs.ApplicationGatewayBackendHttpSettingAuthenticationCertificate']] = None,
                 connection_draining: Optional['outputs.ApplicationGatewayBackendHttpSettingConnectionDraining'] = None,
                 host_name: Optional[str] = None,
                 id: Optional[str] = None,
                 path: Optional[str] = None,
                 pick_host_name_from_backend_address: Optional[bool] = None,
                 probe_id: Optional[str] = None,
                 probe_name: Optional[str] = None,
                 request_timeout: Optional[float] = None,
                 trusted_root_certificate_names: Optional[List[str]] = None):
        """
        :param str cookie_based_affinity: Is Cookie-Based Affinity enabled? Possible values are `Enabled` and `Disabled`.
        :param str name: The name of the Backend HTTP Settings Collection.
        :param float port: The port which should be used for this Backend HTTP Settings Collection.
        :param str protocol: The Protocol which should be used. Possible values are `Http` and `Https`.
        :param str affinity_cookie_name: The name of the affinity cookie.
        :param List['ApplicationGatewayBackendHttpSettingAuthenticationCertificateArgs'] authentication_certificates: One or more `authentication_certificate` blocks.
        :param 'ApplicationGatewayBackendHttpSettingConnectionDrainingArgs' connection_draining: A `connection_draining` block as defined below.
        :param str host_name: Host header to be sent to the backend servers. Cannot be set if `pick_host_name_from_backend_address` is set to `true`.
        :param str id: The ID of the Rewrite Rule Set
        :param str path: The Path which should be used as a prefix for all HTTP requests.
        :param bool pick_host_name_from_backend_address: Whether host header should be picked from the host name of the backend server. Defaults to `false`.
        :param str probe_id: The ID of the associated Probe.
        :param str probe_name: The name of an associated HTTP Probe.
        :param float request_timeout: The request timeout in seconds, which must be between 1 and 86400 seconds.
        :param List[str] trusted_root_certificate_names: A list of `trusted_root_certificate` names.
        """
        pulumi.set(__self__, "cookie_based_affinity", cookie_based_affinity)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)
        if affinity_cookie_name is not None:
            pulumi.set(__self__, "affinity_cookie_name", affinity_cookie_name)
        if authentication_certificates is not None:
            pulumi.set(__self__, "authentication_certificates", authentication_certificates)
        if connection_draining is not None:
            pulumi.set(__self__, "connection_draining", connection_draining)
        if host_name is not None:
            pulumi.set(__self__, "host_name", host_name)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if pick_host_name_from_backend_address is not None:
            pulumi.set(__self__, "pick_host_name_from_backend_address", pick_host_name_from_backend_address)
        if probe_id is not None:
            pulumi.set(__self__, "probe_id", probe_id)
        if probe_name is not None:
            pulumi.set(__self__, "probe_name", probe_name)
        if request_timeout is not None:
            pulumi.set(__self__, "request_timeout", request_timeout)
        if trusted_root_certificate_names is not None:
            pulumi.set(__self__, "trusted_root_certificate_names", trusted_root_certificate_names)

    @property
    @pulumi.getter(name="cookieBasedAffinity")
    def cookie_based_affinity(self) -> str:
        """
        Is Cookie-Based Affinity enabled? Possible values are `Enabled` and `Disabled`.
        """
        return pulumi.get(self, "cookie_based_affinity")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Backend HTTP Settings Collection.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def port(self) -> float:
        """
        The port which should be used for this Backend HTTP Settings Collection.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The Protocol which should be used. Possible values are `Http` and `Https`.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="affinityCookieName")
    def affinity_cookie_name(self) -> Optional[str]:
        """
        The name of the affinity cookie.
        """
        return pulumi.get(self, "affinity_cookie_name")

    @property
    @pulumi.getter(name="authenticationCertificates")
    def authentication_certificates(self) -> Optional[List['outputs.ApplicationGatewayBackendHttpSettingAuthenticationCertificate']]:
        """
        One or more `authentication_certificate` blocks.
        """
        return pulumi.get(self, "authentication_certificates")

    @property
    @pulumi.getter(name="connectionDraining")
    def connection_draining(self) -> Optional['outputs.ApplicationGatewayBackendHttpSettingConnectionDraining']:
        """
        A `connection_draining` block as defined below.
        """
        return pulumi.get(self, "connection_draining")

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> Optional[str]:
        """
        Host header to be sent to the backend servers. Cannot be set if `pick_host_name_from_backend_address` is set to `true`.
        """
        return pulumi.get(self, "host_name")

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

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The Path which should be used as a prefix for all HTTP requests.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter(name="pickHostNameFromBackendAddress")
    def pick_host_name_from_backend_address(self) -> Optional[bool]:
        """
        Whether host header should be picked from the host name of the backend server. Defaults to `false`.
        """
        return pulumi.get(self, "pick_host_name_from_backend_address")

    @property
    @pulumi.getter(name="probeId")
    def probe_id(self) -> Optional[str]:
        """
        The ID of the associated Probe.
        """
        return pulumi.get(self, "probe_id")

    @property
    @pulumi.getter(name="probeName")
    def probe_name(self) -> Optional[str]:
        """
        The name of an associated HTTP Probe.
        """
        return pulumi.get(self, "probe_name")

    @property
    @pulumi.getter(name="requestTimeout")
    def request_timeout(self) -> Optional[float]:
        """
        The request timeout in seconds, which must be between 1 and 86400 seconds.
        """
        return pulumi.get(self, "request_timeout")

    @property
    @pulumi.getter(name="trustedRootCertificateNames")
    def trusted_root_certificate_names(self) -> Optional[List[str]]:
        """
        A list of `trusted_root_certificate` names.
        """
        return pulumi.get(self, "trusted_root_certificate_names")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayBackendHttpSettingAuthenticationCertificate(dict):
    def __init__(__self__, *,
                 name: str,
                 id: Optional[str] = None):
        """
        :param str name: The name of the Authentication Certificate.
        :param str id: The ID of the Rewrite Rule Set
        """
        pulumi.set(__self__, "name", name)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Authentication Certificate.
        """
        return pulumi.get(self, "name")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayBackendHttpSettingConnectionDraining(dict):
    def __init__(__self__, *,
                 drain_timeout_sec: float,
                 enabled: bool):
        """
        :param float drain_timeout_sec: The number of seconds connection draining is active. Acceptable values are from `1` second to `3600` seconds.
        :param bool enabled: If connection draining is enabled or not.
        """
        pulumi.set(__self__, "drain_timeout_sec", drain_timeout_sec)
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="drainTimeoutSec")
    def drain_timeout_sec(self) -> float:
        """
        The number of seconds connection draining is active. Acceptable values are from `1` second to `3600` seconds.
        """
        return pulumi.get(self, "drain_timeout_sec")

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        If connection draining is enabled or not.
        """
        return pulumi.get(self, "enabled")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayCustomErrorConfiguration(dict):
    def __init__(__self__, *,
                 custom_error_page_url: str,
                 status_code: str,
                 id: Optional[str] = None):
        """
        :param str custom_error_page_url: Error page URL of the application gateway customer error.
        :param str status_code: Status code of the application gateway customer error. Possible values are `HttpStatus403` and `HttpStatus502`
        :param str id: The ID of the Rewrite Rule Set
        """
        pulumi.set(__self__, "custom_error_page_url", custom_error_page_url)
        pulumi.set(__self__, "status_code", status_code)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter(name="customErrorPageUrl")
    def custom_error_page_url(self) -> str:
        """
        Error page URL of the application gateway customer error.
        """
        return pulumi.get(self, "custom_error_page_url")

    @property
    @pulumi.getter(name="statusCode")
    def status_code(self) -> str:
        """
        Status code of the application gateway customer error. Possible values are `HttpStatus403` and `HttpStatus502`
        """
        return pulumi.get(self, "status_code")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayFrontendIpConfiguration(dict):
    def __init__(__self__, *,
                 name: str,
                 id: Optional[str] = None,
                 private_ip_address: Optional[str] = None,
                 private_ip_address_allocation: Optional[str] = None,
                 public_ip_address_id: Optional[str] = None,
                 subnet_id: Optional[str] = None):
        """
        :param str name: The name of the Frontend IP Configuration.
        :param str id: The ID of the Rewrite Rule Set
        :param str private_ip_address: The Private IP Address to use for the Application Gateway.
        :param str private_ip_address_allocation: The Allocation Method for the Private IP Address. Possible values are `Dynamic` and `Static`.
        :param str public_ip_address_id: The ID of a Public IP Address which the Application Gateway should use.
        :param str subnet_id: The ID of the Subnet.
        """
        pulumi.set(__self__, "name", name)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if private_ip_address is not None:
            pulumi.set(__self__, "private_ip_address", private_ip_address)
        if private_ip_address_allocation is not None:
            pulumi.set(__self__, "private_ip_address_allocation", private_ip_address_allocation)
        if public_ip_address_id is not None:
            pulumi.set(__self__, "public_ip_address_id", public_ip_address_id)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Frontend IP Configuration.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> Optional[str]:
        """
        The Private IP Address to use for the Application Gateway.
        """
        return pulumi.get(self, "private_ip_address")

    @property
    @pulumi.getter(name="privateIpAddressAllocation")
    def private_ip_address_allocation(self) -> Optional[str]:
        """
        The Allocation Method for the Private IP Address. Possible values are `Dynamic` and `Static`.
        """
        return pulumi.get(self, "private_ip_address_allocation")

    @property
    @pulumi.getter(name="publicIpAddressId")
    def public_ip_address_id(self) -> Optional[str]:
        """
        The ID of a Public IP Address which the Application Gateway should use.
        """
        return pulumi.get(self, "public_ip_address_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet.
        """
        return pulumi.get(self, "subnet_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayFrontendPort(dict):
    def __init__(__self__, *,
                 name: str,
                 port: float,
                 id: Optional[str] = None):
        """
        :param str name: The name of the Frontend Port.
        :param float port: The port used for this Frontend Port.
        :param str id: The ID of the Rewrite Rule Set
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "port", port)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Frontend Port.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def port(self) -> float:
        """
        The port used for this Frontend Port.
        """
        return pulumi.get(self, "port")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayGatewayIpConfiguration(dict):
    def __init__(__self__, *,
                 name: str,
                 subnet_id: str,
                 id: Optional[str] = None):
        """
        :param str name: The Name of this Gateway IP Configuration.
        :param str subnet_id: The ID of the Subnet which the Application Gateway should be connected to.
        :param str id: The ID of the Rewrite Rule Set
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "subnet_id", subnet_id)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Name of this Gateway IP Configuration.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        The ID of the Subnet which the Application Gateway should be connected to.
        """
        return pulumi.get(self, "subnet_id")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayHttpListener(dict):
    def __init__(__self__, *,
                 frontend_ip_configuration_name: str,
                 frontend_port_name: str,
                 name: str,
                 protocol: str,
                 custom_error_configurations: Optional[List['outputs.ApplicationGatewayHttpListenerCustomErrorConfiguration']] = None,
                 firewall_policy_id: Optional[str] = None,
                 frontend_ip_configuration_id: Optional[str] = None,
                 frontend_port_id: Optional[str] = None,
                 host_name: Optional[str] = None,
                 host_names: Optional[List[str]] = None,
                 id: Optional[str] = None,
                 require_sni: Optional[bool] = None,
                 ssl_certificate_id: Optional[str] = None,
                 ssl_certificate_name: Optional[str] = None):
        """
        :param str frontend_ip_configuration_name: The Name of the Frontend IP Configuration used for this HTTP Listener.
        :param str frontend_port_name: The Name of the Frontend Port use for this HTTP Listener.
        :param str name: The Name of the HTTP Listener.
        :param str protocol: The Protocol to use for this HTTP Listener. Possible values are `Http` and `Https`.
        :param List['ApplicationGatewayHttpListenerCustomErrorConfigurationArgs'] custom_error_configurations: One or more `custom_error_configuration` blocks as defined below.
        :param str firewall_policy_id: The ID of the Web Application Firewall Policy which should be used as a HTTP Listener.
        :param str frontend_ip_configuration_id: The ID of the associated Frontend Configuration.
        :param str frontend_port_id: The ID of the associated Frontend Port.
        :param str host_name: The Hostname which should be used for this HTTP Listener.
        :param List[str] host_names: A list of Hostname(s) should be used for this HTTP Listener. It allows special wildcard characters.
        :param str id: The ID of the Rewrite Rule Set
        :param bool require_sni: Should Server Name Indication be Required? Defaults to `false`.
        :param str ssl_certificate_id: The ID of the associated SSL Certificate.
        :param str ssl_certificate_name: The name of the associated SSL Certificate which should be used for this HTTP Listener.
        """
        pulumi.set(__self__, "frontend_ip_configuration_name", frontend_ip_configuration_name)
        pulumi.set(__self__, "frontend_port_name", frontend_port_name)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "protocol", protocol)
        if custom_error_configurations is not None:
            pulumi.set(__self__, "custom_error_configurations", custom_error_configurations)
        if firewall_policy_id is not None:
            pulumi.set(__self__, "firewall_policy_id", firewall_policy_id)
        if frontend_ip_configuration_id is not None:
            pulumi.set(__self__, "frontend_ip_configuration_id", frontend_ip_configuration_id)
        if frontend_port_id is not None:
            pulumi.set(__self__, "frontend_port_id", frontend_port_id)
        if host_name is not None:
            pulumi.set(__self__, "host_name", host_name)
        if host_names is not None:
            pulumi.set(__self__, "host_names", host_names)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if require_sni is not None:
            pulumi.set(__self__, "require_sni", require_sni)
        if ssl_certificate_id is not None:
            pulumi.set(__self__, "ssl_certificate_id", ssl_certificate_id)
        if ssl_certificate_name is not None:
            pulumi.set(__self__, "ssl_certificate_name", ssl_certificate_name)

    @property
    @pulumi.getter(name="frontendIpConfigurationName")
    def frontend_ip_configuration_name(self) -> str:
        """
        The Name of the Frontend IP Configuration used for this HTTP Listener.
        """
        return pulumi.get(self, "frontend_ip_configuration_name")

    @property
    @pulumi.getter(name="frontendPortName")
    def frontend_port_name(self) -> str:
        """
        The Name of the Frontend Port use for this HTTP Listener.
        """
        return pulumi.get(self, "frontend_port_name")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Name of the HTTP Listener.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The Protocol to use for this HTTP Listener. Possible values are `Http` and `Https`.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="customErrorConfigurations")
    def custom_error_configurations(self) -> Optional[List['outputs.ApplicationGatewayHttpListenerCustomErrorConfiguration']]:
        """
        One or more `custom_error_configuration` blocks as defined below.
        """
        return pulumi.get(self, "custom_error_configurations")

    @property
    @pulumi.getter(name="firewallPolicyId")
    def firewall_policy_id(self) -> Optional[str]:
        """
        The ID of the Web Application Firewall Policy which should be used as a HTTP Listener.
        """
        return pulumi.get(self, "firewall_policy_id")

    @property
    @pulumi.getter(name="frontendIpConfigurationId")
    def frontend_ip_configuration_id(self) -> Optional[str]:
        """
        The ID of the associated Frontend Configuration.
        """
        return pulumi.get(self, "frontend_ip_configuration_id")

    @property
    @pulumi.getter(name="frontendPortId")
    def frontend_port_id(self) -> Optional[str]:
        """
        The ID of the associated Frontend Port.
        """
        return pulumi.get(self, "frontend_port_id")

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> Optional[str]:
        """
        The Hostname which should be used for this HTTP Listener.
        """
        return pulumi.get(self, "host_name")

    @property
    @pulumi.getter(name="hostNames")
    def host_names(self) -> Optional[List[str]]:
        """
        A list of Hostname(s) should be used for this HTTP Listener. It allows special wildcard characters.
        """
        return pulumi.get(self, "host_names")

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

    @property
    @pulumi.getter(name="requireSni")
    def require_sni(self) -> Optional[bool]:
        """
        Should Server Name Indication be Required? Defaults to `false`.
        """
        return pulumi.get(self, "require_sni")

    @property
    @pulumi.getter(name="sslCertificateId")
    def ssl_certificate_id(self) -> Optional[str]:
        """
        The ID of the associated SSL Certificate.
        """
        return pulumi.get(self, "ssl_certificate_id")

    @property
    @pulumi.getter(name="sslCertificateName")
    def ssl_certificate_name(self) -> Optional[str]:
        """
        The name of the associated SSL Certificate which should be used for this HTTP Listener.
        """
        return pulumi.get(self, "ssl_certificate_name")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayHttpListenerCustomErrorConfiguration(dict):
    def __init__(__self__, *,
                 custom_error_page_url: str,
                 status_code: str,
                 id: Optional[str] = None):
        """
        :param str custom_error_page_url: Error page URL of the application gateway customer error.
        :param str status_code: Status code of the application gateway customer error. Possible values are `HttpStatus403` and `HttpStatus502`
        :param str id: The ID of the Rewrite Rule Set
        """
        pulumi.set(__self__, "custom_error_page_url", custom_error_page_url)
        pulumi.set(__self__, "status_code", status_code)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter(name="customErrorPageUrl")
    def custom_error_page_url(self) -> str:
        """
        Error page URL of the application gateway customer error.
        """
        return pulumi.get(self, "custom_error_page_url")

    @property
    @pulumi.getter(name="statusCode")
    def status_code(self) -> str:
        """
        Status code of the application gateway customer error. Possible values are `HttpStatus403` and `HttpStatus502`
        """
        return pulumi.get(self, "status_code")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayIdentity(dict):
    def __init__(__self__, *,
                 identity_ids: str,
                 type: Optional[str] = None):
        """
        :param str identity_ids: Specifies a list with a single user managed identity id to be assigned to the Application Gateway.
        :param str type: The Managed Service Identity Type of this Application Gateway. The only possible value is `UserAssigned`. Defaults to `UserAssigned`.
        """
        pulumi.set(__self__, "identity_ids", identity_ids)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> str:
        """
        Specifies a list with a single user managed identity id to be assigned to the Application Gateway.
        """
        return pulumi.get(self, "identity_ids")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The Managed Service Identity Type of this Application Gateway. The only possible value is `UserAssigned`. Defaults to `UserAssigned`.
        """
        return pulumi.get(self, "type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayProbe(dict):
    def __init__(__self__, *,
                 interval: float,
                 name: str,
                 path: str,
                 protocol: str,
                 timeout: float,
                 unhealthy_threshold: float,
                 host: Optional[str] = None,
                 id: Optional[str] = None,
                 match: Optional['outputs.ApplicationGatewayProbeMatch'] = None,
                 minimum_servers: Optional[float] = None,
                 pick_host_name_from_backend_http_settings: Optional[bool] = None,
                 port: Optional[float] = None):
        """
        :param float interval: The Interval between two consecutive probes in seconds. Possible values range from 1 second to a maximum of 86,400 seconds.
        :param str name: The Name of the Probe.
        :param str path: The Path used for this Probe.
        :param str protocol: The Protocol used for this Probe. Possible values are `Http` and `Https`.
        :param float timeout: The Timeout used for this Probe, which indicates when a probe becomes unhealthy. Possible values range from 1 second to a maximum of 86,400 seconds.
        :param float unhealthy_threshold: The Unhealthy Threshold for this Probe, which indicates the amount of retries which should be attempted before a node is deemed unhealthy. Possible values are from 1 - 20 seconds.
        :param str host: The Hostname used for this Probe. If the Application Gateway is configured for a single site, by default the Host name should be specified as ‘127.0.0.1’, unless otherwise configured in custom probe. Cannot be set if `pick_host_name_from_backend_http_settings` is set to `true`.
        :param str id: The ID of the Rewrite Rule Set
        :param 'ApplicationGatewayProbeMatchArgs' match: A `match` block as defined above.
        :param float minimum_servers: The minimum number of servers that are always marked as healthy. Defaults to `0`.
        :param bool pick_host_name_from_backend_http_settings: Whether the host header should be picked from the backend http settings. Defaults to `false`.
        :param float port: Custom port which will be used for probing the backend servers. The valid value ranges from 1 to 65535. In case not set, port from http settings will be used. This property is valid for Standard_v2 and WAF_v2 only.
        """
        pulumi.set(__self__, "interval", interval)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "timeout", timeout)
        pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if match is not None:
            pulumi.set(__self__, "match", match)
        if minimum_servers is not None:
            pulumi.set(__self__, "minimum_servers", minimum_servers)
        if pick_host_name_from_backend_http_settings is not None:
            pulumi.set(__self__, "pick_host_name_from_backend_http_settings", pick_host_name_from_backend_http_settings)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def interval(self) -> float:
        """
        The Interval between two consecutive probes in seconds. Possible values range from 1 second to a maximum of 86,400 seconds.
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Name of the Probe.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        The Path used for this Probe.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The Protocol used for this Probe. Possible values are `Http` and `Https`.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter
    def timeout(self) -> float:
        """
        The Timeout used for this Probe, which indicates when a probe becomes unhealthy. Possible values range from 1 second to a maximum of 86,400 seconds.
        """
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter(name="unhealthyThreshold")
    def unhealthy_threshold(self) -> float:
        """
        The Unhealthy Threshold for this Probe, which indicates the amount of retries which should be attempted before a node is deemed unhealthy. Possible values are from 1 - 20 seconds.
        """
        return pulumi.get(self, "unhealthy_threshold")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        The Hostname used for this Probe. If the Application Gateway is configured for a single site, by default the Host name should be specified as ‘127.0.0.1’, unless otherwise configured in custom probe. Cannot be set if `pick_host_name_from_backend_http_settings` is set to `true`.
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def match(self) -> Optional['outputs.ApplicationGatewayProbeMatch']:
        """
        A `match` block as defined above.
        """
        return pulumi.get(self, "match")

    @property
    @pulumi.getter(name="minimumServers")
    def minimum_servers(self) -> Optional[float]:
        """
        The minimum number of servers that are always marked as healthy. Defaults to `0`.
        """
        return pulumi.get(self, "minimum_servers")

    @property
    @pulumi.getter(name="pickHostNameFromBackendHttpSettings")
    def pick_host_name_from_backend_http_settings(self) -> Optional[bool]:
        """
        Whether the host header should be picked from the backend http settings. Defaults to `false`.
        """
        return pulumi.get(self, "pick_host_name_from_backend_http_settings")

    @property
    @pulumi.getter
    def port(self) -> Optional[float]:
        """
        Custom port which will be used for probing the backend servers. The valid value ranges from 1 to 65535. In case not set, port from http settings will be used. This property is valid for Standard_v2 and WAF_v2 only.
        """
        return pulumi.get(self, "port")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayProbeMatch(dict):
    def __init__(__self__, *,
                 body: Optional[str] = None,
                 status_codes: Optional[List[str]] = None):
        """
        :param str body: A snippet from the Response Body which must be present in the Response..
        :param List[str] status_codes: A list of allowed status codes for this Health Probe.
        """
        if body is not None:
            pulumi.set(__self__, "body", body)
        if status_codes is not None:
            pulumi.set(__self__, "status_codes", status_codes)

    @property
    @pulumi.getter
    def body(self) -> Optional[str]:
        """
        A snippet from the Response Body which must be present in the Response..
        """
        return pulumi.get(self, "body")

    @property
    @pulumi.getter(name="statusCodes")
    def status_codes(self) -> Optional[List[str]]:
        """
        A list of allowed status codes for this Health Probe.
        """
        return pulumi.get(self, "status_codes")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayRedirectConfiguration(dict):
    def __init__(__self__, *,
                 name: str,
                 redirect_type: str,
                 id: Optional[str] = None,
                 include_path: Optional[bool] = None,
                 include_query_string: Optional[bool] = None,
                 target_listener_id: Optional[str] = None,
                 target_listener_name: Optional[str] = None,
                 target_url: Optional[str] = None):
        """
        :param str name: Unique name of the redirect configuration block
        :param str redirect_type: The type of redirect. Possible values are `Permanent`, `Temporary`, `Found` and `SeeOther`
        :param str id: The ID of the Rewrite Rule Set
        :param bool include_path: Whether or not to include the path in the redirected Url. Defaults to `false`
        :param bool include_query_string: Whether or not to include the query string in the redirected Url. Default to `false`
        :param str target_listener_name: The name of the listener to redirect to. Cannot be set if `target_url` is set.
        :param str target_url: The Url to redirect the request to. Cannot be set if `target_listener_name` is set.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "redirect_type", redirect_type)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if include_path is not None:
            pulumi.set(__self__, "include_path", include_path)
        if include_query_string is not None:
            pulumi.set(__self__, "include_query_string", include_query_string)
        if target_listener_id is not None:
            pulumi.set(__self__, "target_listener_id", target_listener_id)
        if target_listener_name is not None:
            pulumi.set(__self__, "target_listener_name", target_listener_name)
        if target_url is not None:
            pulumi.set(__self__, "target_url", target_url)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Unique name of the redirect configuration block
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="redirectType")
    def redirect_type(self) -> str:
        """
        The type of redirect. Possible values are `Permanent`, `Temporary`, `Found` and `SeeOther`
        """
        return pulumi.get(self, "redirect_type")

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

    @property
    @pulumi.getter(name="includePath")
    def include_path(self) -> Optional[bool]:
        """
        Whether or not to include the path in the redirected Url. Defaults to `false`
        """
        return pulumi.get(self, "include_path")

    @property
    @pulumi.getter(name="includeQueryString")
    def include_query_string(self) -> Optional[bool]:
        """
        Whether or not to include the query string in the redirected Url. Default to `false`
        """
        return pulumi.get(self, "include_query_string")

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

    @property
    @pulumi.getter(name="targetListenerName")
    def target_listener_name(self) -> Optional[str]:
        """
        The name of the listener to redirect to. Cannot be set if `target_url` is set.
        """
        return pulumi.get(self, "target_listener_name")

    @property
    @pulumi.getter(name="targetUrl")
    def target_url(self) -> Optional[str]:
        """
        The Url to redirect the request to. Cannot be set if `target_listener_name` is set.
        """
        return pulumi.get(self, "target_url")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayRequestRoutingRule(dict):
    def __init__(__self__, *,
                 http_listener_name: str,
                 name: str,
                 rule_type: str,
                 backend_address_pool_id: Optional[str] = None,
                 backend_address_pool_name: Optional[str] = None,
                 backend_http_settings_id: Optional[str] = None,
                 backend_http_settings_name: Optional[str] = None,
                 http_listener_id: Optional[str] = None,
                 id: Optional[str] = None,
                 redirect_configuration_id: Optional[str] = None,
                 redirect_configuration_name: Optional[str] = None,
                 rewrite_rule_set_id: Optional[str] = None,
                 rewrite_rule_set_name: Optional[str] = None,
                 url_path_map_id: Optional[str] = None,
                 url_path_map_name: Optional[str] = None):
        """
        :param str http_listener_name: The Name of the HTTP Listener which should be used for this Routing Rule.
        :param str name: The Name of this Request Routing Rule.
        :param str rule_type: The Type of Routing that should be used for this Rule. Possible values are `Basic` and `PathBasedRouting`.
        :param str backend_address_pool_id: The ID of the associated Backend Address Pool.
        :param str backend_address_pool_name: The Name of the Backend Address Pool which should be used for this Routing Rule. Cannot be set if `redirect_configuration_name` is set.
        :param str backend_http_settings_id: The ID of the associated Backend HTTP Settings Configuration.
        :param str backend_http_settings_name: The Name of the Backend HTTP Settings Collection which should be used for this Routing Rule. Cannot be set if `redirect_configuration_name` is set.
        :param str http_listener_id: The ID of the associated HTTP Listener.
        :param str id: The ID of the Rewrite Rule Set
        :param str redirect_configuration_id: The ID of the associated Redirect Configuration.
        :param str redirect_configuration_name: The Name of the Redirect Configuration which should be used for this Routing Rule. Cannot be set if either `backend_address_pool_name` or `backend_http_settings_name` is set.
        :param str rewrite_rule_set_id: The ID of the associated Rewrite Rule Set.
        :param str rewrite_rule_set_name: The Name of the Rewrite Rule Set which should be used for this Routing Rule. Only valid for v2 SKUs.
        :param str url_path_map_id: The ID of the associated URL Path Map.
        :param str url_path_map_name: The Name of the URL Path Map which should be associated with this Routing Rule.
        """
        pulumi.set(__self__, "http_listener_name", http_listener_name)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "rule_type", rule_type)
        if backend_address_pool_id is not None:
            pulumi.set(__self__, "backend_address_pool_id", backend_address_pool_id)
        if backend_address_pool_name is not None:
            pulumi.set(__self__, "backend_address_pool_name", backend_address_pool_name)
        if backend_http_settings_id is not None:
            pulumi.set(__self__, "backend_http_settings_id", backend_http_settings_id)
        if backend_http_settings_name is not None:
            pulumi.set(__self__, "backend_http_settings_name", backend_http_settings_name)
        if http_listener_id is not None:
            pulumi.set(__self__, "http_listener_id", http_listener_id)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if redirect_configuration_id is not None:
            pulumi.set(__self__, "redirect_configuration_id", redirect_configuration_id)
        if redirect_configuration_name is not None:
            pulumi.set(__self__, "redirect_configuration_name", redirect_configuration_name)
        if rewrite_rule_set_id is not None:
            pulumi.set(__self__, "rewrite_rule_set_id", rewrite_rule_set_id)
        if rewrite_rule_set_name is not None:
            pulumi.set(__self__, "rewrite_rule_set_name", rewrite_rule_set_name)
        if url_path_map_id is not None:
            pulumi.set(__self__, "url_path_map_id", url_path_map_id)
        if url_path_map_name is not None:
            pulumi.set(__self__, "url_path_map_name", url_path_map_name)

    @property
    @pulumi.getter(name="httpListenerName")
    def http_listener_name(self) -> str:
        """
        The Name of the HTTP Listener which should be used for this Routing Rule.
        """
        return pulumi.get(self, "http_listener_name")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Name of this Request Routing Rule.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="ruleType")
    def rule_type(self) -> str:
        """
        The Type of Routing that should be used for this Rule. Possible values are `Basic` and `PathBasedRouting`.
        """
        return pulumi.get(self, "rule_type")

    @property
    @pulumi.getter(name="backendAddressPoolId")
    def backend_address_pool_id(self) -> Optional[str]:
        """
        The ID of the associated Backend Address Pool.
        """
        return pulumi.get(self, "backend_address_pool_id")

    @property
    @pulumi.getter(name="backendAddressPoolName")
    def backend_address_pool_name(self) -> Optional[str]:
        """
        The Name of the Backend Address Pool which should be used for this Routing Rule. Cannot be set if `redirect_configuration_name` is set.
        """
        return pulumi.get(self, "backend_address_pool_name")

    @property
    @pulumi.getter(name="backendHttpSettingsId")
    def backend_http_settings_id(self) -> Optional[str]:
        """
        The ID of the associated Backend HTTP Settings Configuration.
        """
        return pulumi.get(self, "backend_http_settings_id")

    @property
    @pulumi.getter(name="backendHttpSettingsName")
    def backend_http_settings_name(self) -> Optional[str]:
        """
        The Name of the Backend HTTP Settings Collection which should be used for this Routing Rule. Cannot be set if `redirect_configuration_name` is set.
        """
        return pulumi.get(self, "backend_http_settings_name")

    @property
    @pulumi.getter(name="httpListenerId")
    def http_listener_id(self) -> Optional[str]:
        """
        The ID of the associated HTTP Listener.
        """
        return pulumi.get(self, "http_listener_id")

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

    @property
    @pulumi.getter(name="redirectConfigurationId")
    def redirect_configuration_id(self) -> Optional[str]:
        """
        The ID of the associated Redirect Configuration.
        """
        return pulumi.get(self, "redirect_configuration_id")

    @property
    @pulumi.getter(name="redirectConfigurationName")
    def redirect_configuration_name(self) -> Optional[str]:
        """
        The Name of the Redirect Configuration which should be used for this Routing Rule. Cannot be set if either `backend_address_pool_name` or `backend_http_settings_name` is set.
        """
        return pulumi.get(self, "redirect_configuration_name")

    @property
    @pulumi.getter(name="rewriteRuleSetId")
    def rewrite_rule_set_id(self) -> Optional[str]:
        """
        The ID of the associated Rewrite Rule Set.
        """
        return pulumi.get(self, "rewrite_rule_set_id")

    @property
    @pulumi.getter(name="rewriteRuleSetName")
    def rewrite_rule_set_name(self) -> Optional[str]:
        """
        The Name of the Rewrite Rule Set which should be used for this Routing Rule. Only valid for v2 SKUs.
        """
        return pulumi.get(self, "rewrite_rule_set_name")

    @property
    @pulumi.getter(name="urlPathMapId")
    def url_path_map_id(self) -> Optional[str]:
        """
        The ID of the associated URL Path Map.
        """
        return pulumi.get(self, "url_path_map_id")

    @property
    @pulumi.getter(name="urlPathMapName")
    def url_path_map_name(self) -> Optional[str]:
        """
        The Name of the URL Path Map which should be associated with this Routing Rule.
        """
        return pulumi.get(self, "url_path_map_name")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayRewriteRuleSet(dict):
    def __init__(__self__, *,
                 name: str,
                 id: Optional[str] = None,
                 rewrite_rules: Optional[List['outputs.ApplicationGatewayRewriteRuleSetRewriteRule']] = None):
        """
        :param str name: Unique name of the rewrite rule set block
        :param str id: The ID of the Rewrite Rule Set
        :param List['ApplicationGatewayRewriteRuleSetRewriteRuleArgs'] rewrite_rules: One or more `rewrite_rule` blocks as defined above.
        """
        pulumi.set(__self__, "name", name)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if rewrite_rules is not None:
            pulumi.set(__self__, "rewrite_rules", rewrite_rules)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Unique name of the rewrite rule set block
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="rewriteRules")
    def rewrite_rules(self) -> Optional[List['outputs.ApplicationGatewayRewriteRuleSetRewriteRule']]:
        """
        One or more `rewrite_rule` blocks as defined above.
        """
        return pulumi.get(self, "rewrite_rules")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayRewriteRuleSetRewriteRule(dict):
    def __init__(__self__, *,
                 name: str,
                 rule_sequence: float,
                 conditions: Optional[List['outputs.ApplicationGatewayRewriteRuleSetRewriteRuleCondition']] = None,
                 request_header_configurations: Optional[List['outputs.ApplicationGatewayRewriteRuleSetRewriteRuleRequestHeaderConfiguration']] = None,
                 response_header_configurations: Optional[List['outputs.ApplicationGatewayRewriteRuleSetRewriteRuleResponseHeaderConfiguration']] = None):
        """
        :param str name: Unique name of the rewrite rule block
        :param float rule_sequence: Rule sequence of the rewrite rule that determines the order of execution in a set.
        :param List['ApplicationGatewayRewriteRuleSetRewriteRuleConditionArgs'] conditions: One or more `condition` blocks as defined above.
        :param List['ApplicationGatewayRewriteRuleSetRewriteRuleRequestHeaderConfigurationArgs'] request_header_configurations: One or more `request_header_configuration` blocks as defined above.
        :param List['ApplicationGatewayRewriteRuleSetRewriteRuleResponseHeaderConfigurationArgs'] response_header_configurations: One or more `response_header_configuration` blocks as defined above.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "rule_sequence", rule_sequence)
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if request_header_configurations is not None:
            pulumi.set(__self__, "request_header_configurations", request_header_configurations)
        if response_header_configurations is not None:
            pulumi.set(__self__, "response_header_configurations", response_header_configurations)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Unique name of the rewrite rule block
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="ruleSequence")
    def rule_sequence(self) -> float:
        """
        Rule sequence of the rewrite rule that determines the order of execution in a set.
        """
        return pulumi.get(self, "rule_sequence")

    @property
    @pulumi.getter
    def conditions(self) -> Optional[List['outputs.ApplicationGatewayRewriteRuleSetRewriteRuleCondition']]:
        """
        One or more `condition` blocks as defined above.
        """
        return pulumi.get(self, "conditions")

    @property
    @pulumi.getter(name="requestHeaderConfigurations")
    def request_header_configurations(self) -> Optional[List['outputs.ApplicationGatewayRewriteRuleSetRewriteRuleRequestHeaderConfiguration']]:
        """
        One or more `request_header_configuration` blocks as defined above.
        """
        return pulumi.get(self, "request_header_configurations")

    @property
    @pulumi.getter(name="responseHeaderConfigurations")
    def response_header_configurations(self) -> Optional[List['outputs.ApplicationGatewayRewriteRuleSetRewriteRuleResponseHeaderConfiguration']]:
        """
        One or more `response_header_configuration` blocks as defined above.
        """
        return pulumi.get(self, "response_header_configurations")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayRewriteRuleSetRewriteRuleCondition(dict):
    def __init__(__self__, *,
                 pattern: str,
                 variable: str,
                 ignore_case: Optional[bool] = None,
                 negate: Optional[bool] = None):
        """
        :param str pattern: The pattern, either fixed string or regular expression, that evaluates the truthfulness of the condition.
        :param str variable: The [variable](https://docs.microsoft.com/en-us/azure/application-gateway/rewrite-http-headers#server-variables) of the condition.
        :param bool ignore_case: Perform a case in-sensitive comparison. Defaults to `false`
        :param bool negate: Negate the result of the condition evaluation. Defaults to `false`
        """
        pulumi.set(__self__, "pattern", pattern)
        pulumi.set(__self__, "variable", variable)
        if ignore_case is not None:
            pulumi.set(__self__, "ignore_case", ignore_case)
        if negate is not None:
            pulumi.set(__self__, "negate", negate)

    @property
    @pulumi.getter
    def pattern(self) -> str:
        """
        The pattern, either fixed string or regular expression, that evaluates the truthfulness of the condition.
        """
        return pulumi.get(self, "pattern")

    @property
    @pulumi.getter
    def variable(self) -> str:
        """
        The [variable](https://docs.microsoft.com/en-us/azure/application-gateway/rewrite-http-headers#server-variables) of the condition.
        """
        return pulumi.get(self, "variable")

    @property
    @pulumi.getter(name="ignoreCase")
    def ignore_case(self) -> Optional[bool]:
        """
        Perform a case in-sensitive comparison. Defaults to `false`
        """
        return pulumi.get(self, "ignore_case")

    @property
    @pulumi.getter
    def negate(self) -> Optional[bool]:
        """
        Negate the result of the condition evaluation. Defaults to `false`
        """
        return pulumi.get(self, "negate")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayRewriteRuleSetRewriteRuleRequestHeaderConfiguration(dict):
    def __init__(__self__, *,
                 header_name: str,
                 header_value: str):
        """
        :param str header_name: Header name of the header configuration.
        :param str header_value: Header value of the header configuration. To delete a request header set this property to an empty string.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> str:
        """
        Header name of the header configuration.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        Header value of the header configuration. To delete a request header set this property to an empty string.
        """
        return pulumi.get(self, "header_value")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayRewriteRuleSetRewriteRuleResponseHeaderConfiguration(dict):
    def __init__(__self__, *,
                 header_name: str,
                 header_value: str):
        """
        :param str header_name: Header name of the header configuration.
        :param str header_value: Header value of the header configuration. To delete a response header set this property to an empty string.
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> str:
        """
        Header name of the header configuration.
        """
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        """
        Header value of the header configuration. To delete a response header set this property to an empty string.
        """
        return pulumi.get(self, "header_value")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewaySku(dict):
    def __init__(__self__, *,
                 name: str,
                 tier: str,
                 capacity: Optional[float] = None):
        """
        :param str name: The Name of the SKU to use for this Application Gateway. Possible values are `Standard_Small`, `Standard_Medium`, `Standard_Large`, `Standard_v2`, `WAF_Medium`, `WAF_Large`, and `WAF_v2`.
        :param str tier: The Tier of the SKU to use for this Application Gateway. Possible values are `Standard`, `Standard_v2`, `WAF` and `WAF_v2`.
        :param float capacity: The Capacity of the SKU to use for this Application Gateway. When using a V1 SKU this value must be between 1 and 32, and 1 to 125 for a V2 SKU. This property is optional if `autoscale_configuration` is set.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "tier", tier)
        if capacity is not None:
            pulumi.set(__self__, "capacity", capacity)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Name of the SKU to use for this Application Gateway. Possible values are `Standard_Small`, `Standard_Medium`, `Standard_Large`, `Standard_v2`, `WAF_Medium`, `WAF_Large`, and `WAF_v2`.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def tier(self) -> str:
        """
        The Tier of the SKU to use for this Application Gateway. Possible values are `Standard`, `Standard_v2`, `WAF` and `WAF_v2`.
        """
        return pulumi.get(self, "tier")

    @property
    @pulumi.getter
    def capacity(self) -> Optional[float]:
        """
        The Capacity of the SKU to use for this Application Gateway. When using a V1 SKU this value must be between 1 and 32, and 1 to 125 for a V2 SKU. This property is optional if `autoscale_configuration` is set.
        """
        return pulumi.get(self, "capacity")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewaySslCertificate(dict):
    def __init__(__self__, *,
                 name: str,
                 data: Optional[str] = None,
                 id: Optional[str] = None,
                 key_vault_secret_id: Optional[str] = None,
                 password: Optional[str] = None,
                 public_cert_data: Optional[str] = None):
        """
        :param str name: The Name of the SSL certificate that is unique within this Application Gateway
        :param str data: PFX certificate. Required if `key_vault_secret_id` is not set.
        :param str id: The ID of the Rewrite Rule Set
        :param str key_vault_secret_id: Secret Id of (base-64 encoded unencrypted pfx) `Secret` or `Certificate` object stored in Azure KeyVault. You need to enable soft delete for keyvault to use this feature. Required if `data` is not set.
        :param str password: Password for the pfx file specified in data.  Required if `data` is set.
        :param str public_cert_data: The Public Certificate Data associated with the SSL Certificate.
        """
        pulumi.set(__self__, "name", name)
        if data is not None:
            pulumi.set(__self__, "data", data)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if key_vault_secret_id is not None:
            pulumi.set(__self__, "key_vault_secret_id", key_vault_secret_id)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if public_cert_data is not None:
            pulumi.set(__self__, "public_cert_data", public_cert_data)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Name of the SSL certificate that is unique within this Application Gateway
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def data(self) -> Optional[str]:
        """
        PFX certificate. Required if `key_vault_secret_id` is not set.
        """
        return pulumi.get(self, "data")

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

    @property
    @pulumi.getter(name="keyVaultSecretId")
    def key_vault_secret_id(self) -> Optional[str]:
        """
        Secret Id of (base-64 encoded unencrypted pfx) `Secret` or `Certificate` object stored in Azure KeyVault. You need to enable soft delete for keyvault to use this feature. Required if `data` is not set.
        """
        return pulumi.get(self, "key_vault_secret_id")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        Password for the pfx file specified in data.  Required if `data` is set.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="publicCertData")
    def public_cert_data(self) -> Optional[str]:
        """
        The Public Certificate Data associated with the SSL Certificate.
        """
        return pulumi.get(self, "public_cert_data")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewaySslPolicy(dict):
    def __init__(__self__, *,
                 cipher_suites: Optional[List[str]] = None,
                 disabled_protocols: Optional[List[str]] = None,
                 min_protocol_version: Optional[str] = None,
                 policy_name: Optional[str] = None,
                 policy_type: Optional[str] = None):
        """
        :param List[str] cipher_suites: A List of accepted cipher suites. Possible values are: `TLS_DHE_DSS_WITH_AES_128_CBC_SHA`, `TLS_DHE_DSS_WITH_AES_128_CBC_SHA256`, `TLS_DHE_DSS_WITH_AES_256_CBC_SHA`, `TLS_DHE_DSS_WITH_AES_256_CBC_SHA256`, `TLS_DHE_RSA_WITH_AES_128_CBC_SHA`, `TLS_DHE_RSA_WITH_AES_128_GCM_SHA256`, `TLS_DHE_RSA_WITH_AES_256_CBC_SHA`, `TLS_DHE_RSA_WITH_AES_256_GCM_SHA384`, `TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA`, `TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256`, `TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`, `TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA`, `TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384`, `TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384`, `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA`, `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256`, `TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA`, `TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384`, `TLS_RSA_WITH_3DES_EDE_CBC_SHA`, `TLS_RSA_WITH_AES_128_CBC_SHA`, `TLS_RSA_WITH_AES_128_CBC_SHA256`, `TLS_RSA_WITH_AES_128_GCM_SHA256`, `TLS_RSA_WITH_AES_256_CBC_SHA`, `TLS_RSA_WITH_AES_256_CBC_SHA256` and `TLS_RSA_WITH_AES_256_GCM_SHA384`.
        :param List[str] disabled_protocols: A list of SSL Protocols which should be disabled on this Application Gateway. Possible values are `TLSv1_0`, `TLSv1_1` and `TLSv1_2`.
        :param str min_protocol_version: The minimal TLS version. Possible values are `TLSv1_0`, `TLSv1_1` and `TLSv1_2`.
        :param str policy_name: The Name of the Policy e.g AppGwSslPolicy20170401S. Required if `policy_type` is set to `Predefined`. Possible values can change over time and
               are published here https://docs.microsoft.com/en-us/azure/application-gateway/application-gateway-ssl-policy-overview. Not compatible with `disabled_protocols`.
        :param str policy_type: The Type of the Policy. Possible values are `Predefined` and `Custom`.
        """
        if cipher_suites is not None:
            pulumi.set(__self__, "cipher_suites", cipher_suites)
        if disabled_protocols is not None:
            pulumi.set(__self__, "disabled_protocols", disabled_protocols)
        if min_protocol_version is not None:
            pulumi.set(__self__, "min_protocol_version", min_protocol_version)
        if policy_name is not None:
            pulumi.set(__self__, "policy_name", policy_name)
        if policy_type is not None:
            pulumi.set(__self__, "policy_type", policy_type)

    @property
    @pulumi.getter(name="cipherSuites")
    def cipher_suites(self) -> Optional[List[str]]:
        """
        A List of accepted cipher suites. Possible values are: `TLS_DHE_DSS_WITH_AES_128_CBC_SHA`, `TLS_DHE_DSS_WITH_AES_128_CBC_SHA256`, `TLS_DHE_DSS_WITH_AES_256_CBC_SHA`, `TLS_DHE_DSS_WITH_AES_256_CBC_SHA256`, `TLS_DHE_RSA_WITH_AES_128_CBC_SHA`, `TLS_DHE_RSA_WITH_AES_128_GCM_SHA256`, `TLS_DHE_RSA_WITH_AES_256_CBC_SHA`, `TLS_DHE_RSA_WITH_AES_256_GCM_SHA384`, `TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA`, `TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256`, `TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`, `TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA`, `TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384`, `TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384`, `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA`, `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256`, `TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA`, `TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384`, `TLS_RSA_WITH_3DES_EDE_CBC_SHA`, `TLS_RSA_WITH_AES_128_CBC_SHA`, `TLS_RSA_WITH_AES_128_CBC_SHA256`, `TLS_RSA_WITH_AES_128_GCM_SHA256`, `TLS_RSA_WITH_AES_256_CBC_SHA`, `TLS_RSA_WITH_AES_256_CBC_SHA256` and `TLS_RSA_WITH_AES_256_GCM_SHA384`.
        """
        return pulumi.get(self, "cipher_suites")

    @property
    @pulumi.getter(name="disabledProtocols")
    def disabled_protocols(self) -> Optional[List[str]]:
        """
        A list of SSL Protocols which should be disabled on this Application Gateway. Possible values are `TLSv1_0`, `TLSv1_1` and `TLSv1_2`.
        """
        return pulumi.get(self, "disabled_protocols")

    @property
    @pulumi.getter(name="minProtocolVersion")
    def min_protocol_version(self) -> Optional[str]:
        """
        The minimal TLS version. Possible values are `TLSv1_0`, `TLSv1_1` and `TLSv1_2`.
        """
        return pulumi.get(self, "min_protocol_version")

    @property
    @pulumi.getter(name="policyName")
    def policy_name(self) -> Optional[str]:
        """
        The Name of the Policy e.g AppGwSslPolicy20170401S. Required if `policy_type` is set to `Predefined`. Possible values can change over time and
        are published here https://docs.microsoft.com/en-us/azure/application-gateway/application-gateway-ssl-policy-overview. Not compatible with `disabled_protocols`.
        """
        return pulumi.get(self, "policy_name")

    @property
    @pulumi.getter(name="policyType")
    def policy_type(self) -> Optional[str]:
        """
        The Type of the Policy. Possible values are `Predefined` and `Custom`.
        """
        return pulumi.get(self, "policy_type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayTrustedRootCertificate(dict):
    def __init__(__self__, *,
                 data: str,
                 name: str,
                 id: Optional[str] = None):
        """
        :param str data: The contents of the Trusted Root Certificate which should be used.
        :param str name: The Name of the Trusted Root Certificate to use.
        :param str id: The ID of the Rewrite Rule Set
        """
        pulumi.set(__self__, "data", data)
        pulumi.set(__self__, "name", name)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def data(self) -> str:
        """
        The contents of the Trusted Root Certificate which should be used.
        """
        return pulumi.get(self, "data")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Name of the Trusted Root Certificate to use.
        """
        return pulumi.get(self, "name")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayUrlPathMap(dict):
    def __init__(__self__, *,
                 name: str,
                 path_rules: List['outputs.ApplicationGatewayUrlPathMapPathRule'],
                 default_backend_address_pool_id: Optional[str] = None,
                 default_backend_address_pool_name: Optional[str] = None,
                 default_backend_http_settings_id: Optional[str] = None,
                 default_backend_http_settings_name: Optional[str] = None,
                 default_redirect_configuration_id: Optional[str] = None,
                 default_redirect_configuration_name: Optional[str] = None,
                 default_rewrite_rule_set_id: Optional[str] = None,
                 default_rewrite_rule_set_name: Optional[str] = None,
                 id: Optional[str] = None):
        """
        :param str name: The Name of the URL Path Map.
        :param List['ApplicationGatewayUrlPathMapPathRuleArgs'] path_rules: One or more `path_rule` blocks as defined above.
        :param str default_backend_address_pool_id: The ID of the Default Backend Address Pool.
        :param str default_backend_address_pool_name: The Name of the Default Backend Address Pool which should be used for this URL Path Map. Cannot be set if `default_redirect_configuration_name` is set.
        :param str default_backend_http_settings_id: The ID of the Default Backend HTTP Settings Collection.
        :param str default_backend_http_settings_name: The Name of the Default Backend HTTP Settings Collection which should be used for this URL Path Map. Cannot be set if `default_redirect_configuration_name` is set.
        :param str default_redirect_configuration_id: The ID of the Default Redirect Configuration.
        :param str default_redirect_configuration_name: The Name of the Default Redirect Configuration which should be used for this URL Path Map. Cannot be set if either `default_backend_address_pool_name` or `default_backend_http_settings_name` is set.
        :param str default_rewrite_rule_set_name: The Name of the Default Rewrite Rule Set which should be used for this URL Path Map. Only valid for v2 SKUs.
        :param str id: The ID of the Rewrite Rule Set
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "path_rules", path_rules)
        if default_backend_address_pool_id is not None:
            pulumi.set(__self__, "default_backend_address_pool_id", default_backend_address_pool_id)
        if default_backend_address_pool_name is not None:
            pulumi.set(__self__, "default_backend_address_pool_name", default_backend_address_pool_name)
        if default_backend_http_settings_id is not None:
            pulumi.set(__self__, "default_backend_http_settings_id", default_backend_http_settings_id)
        if default_backend_http_settings_name is not None:
            pulumi.set(__self__, "default_backend_http_settings_name", default_backend_http_settings_name)
        if default_redirect_configuration_id is not None:
            pulumi.set(__self__, "default_redirect_configuration_id", default_redirect_configuration_id)
        if default_redirect_configuration_name is not None:
            pulumi.set(__self__, "default_redirect_configuration_name", default_redirect_configuration_name)
        if default_rewrite_rule_set_id is not None:
            pulumi.set(__self__, "default_rewrite_rule_set_id", default_rewrite_rule_set_id)
        if default_rewrite_rule_set_name is not None:
            pulumi.set(__self__, "default_rewrite_rule_set_name", default_rewrite_rule_set_name)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Name of the URL Path Map.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="pathRules")
    def path_rules(self) -> List['outputs.ApplicationGatewayUrlPathMapPathRule']:
        """
        One or more `path_rule` blocks as defined above.
        """
        return pulumi.get(self, "path_rules")

    @property
    @pulumi.getter(name="defaultBackendAddressPoolId")
    def default_backend_address_pool_id(self) -> Optional[str]:
        """
        The ID of the Default Backend Address Pool.
        """
        return pulumi.get(self, "default_backend_address_pool_id")

    @property
    @pulumi.getter(name="defaultBackendAddressPoolName")
    def default_backend_address_pool_name(self) -> Optional[str]:
        """
        The Name of the Default Backend Address Pool which should be used for this URL Path Map. Cannot be set if `default_redirect_configuration_name` is set.
        """
        return pulumi.get(self, "default_backend_address_pool_name")

    @property
    @pulumi.getter(name="defaultBackendHttpSettingsId")
    def default_backend_http_settings_id(self) -> Optional[str]:
        """
        The ID of the Default Backend HTTP Settings Collection.
        """
        return pulumi.get(self, "default_backend_http_settings_id")

    @property
    @pulumi.getter(name="defaultBackendHttpSettingsName")
    def default_backend_http_settings_name(self) -> Optional[str]:
        """
        The Name of the Default Backend HTTP Settings Collection which should be used for this URL Path Map. Cannot be set if `default_redirect_configuration_name` is set.
        """
        return pulumi.get(self, "default_backend_http_settings_name")

    @property
    @pulumi.getter(name="defaultRedirectConfigurationId")
    def default_redirect_configuration_id(self) -> Optional[str]:
        """
        The ID of the Default Redirect Configuration.
        """
        return pulumi.get(self, "default_redirect_configuration_id")

    @property
    @pulumi.getter(name="defaultRedirectConfigurationName")
    def default_redirect_configuration_name(self) -> Optional[str]:
        """
        The Name of the Default Redirect Configuration which should be used for this URL Path Map. Cannot be set if either `default_backend_address_pool_name` or `default_backend_http_settings_name` is set.
        """
        return pulumi.get(self, "default_redirect_configuration_name")

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

    @property
    @pulumi.getter(name="defaultRewriteRuleSetName")
    def default_rewrite_rule_set_name(self) -> Optional[str]:
        """
        The Name of the Default Rewrite Rule Set which should be used for this URL Path Map. Only valid for v2 SKUs.
        """
        return pulumi.get(self, "default_rewrite_rule_set_name")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayUrlPathMapPathRule(dict):
    def __init__(__self__, *,
                 name: str,
                 paths: List[str],
                 backend_address_pool_id: Optional[str] = None,
                 backend_address_pool_name: Optional[str] = None,
                 backend_http_settings_id: Optional[str] = None,
                 backend_http_settings_name: Optional[str] = None,
                 id: Optional[str] = None,
                 redirect_configuration_id: Optional[str] = None,
                 redirect_configuration_name: Optional[str] = None,
                 rewrite_rule_set_id: Optional[str] = None,
                 rewrite_rule_set_name: Optional[str] = None):
        """
        :param str name: The Name of the Path Rule.
        :param List[str] paths: A list of Paths used in this Path Rule.
        :param str backend_address_pool_id: The ID of the associated Backend Address Pool.
        :param str backend_address_pool_name: The Name of the Backend Address Pool to use for this Path Rule. Cannot be set if `redirect_configuration_name` is set.
        :param str backend_http_settings_id: The ID of the associated Backend HTTP Settings Configuration.
        :param str backend_http_settings_name: The Name of the Backend HTTP Settings Collection to use for this Path Rule. Cannot be set if `redirect_configuration_name` is set.
        :param str id: The ID of the Rewrite Rule Set
        :param str redirect_configuration_id: The ID of the associated Redirect Configuration.
        :param str redirect_configuration_name: The Name of a Redirect Configuration to use for this Path Rule. Cannot be set if `backend_address_pool_name` or `backend_http_settings_name` is set.
        :param str rewrite_rule_set_id: The ID of the associated Rewrite Rule Set.
        :param str rewrite_rule_set_name: The Name of the Rewrite Rule Set which should be used for this URL Path Map. Only valid for v2 SKUs.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "paths", paths)
        if backend_address_pool_id is not None:
            pulumi.set(__self__, "backend_address_pool_id", backend_address_pool_id)
        if backend_address_pool_name is not None:
            pulumi.set(__self__, "backend_address_pool_name", backend_address_pool_name)
        if backend_http_settings_id is not None:
            pulumi.set(__self__, "backend_http_settings_id", backend_http_settings_id)
        if backend_http_settings_name is not None:
            pulumi.set(__self__, "backend_http_settings_name", backend_http_settings_name)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if redirect_configuration_id is not None:
            pulumi.set(__self__, "redirect_configuration_id", redirect_configuration_id)
        if redirect_configuration_name is not None:
            pulumi.set(__self__, "redirect_configuration_name", redirect_configuration_name)
        if rewrite_rule_set_id is not None:
            pulumi.set(__self__, "rewrite_rule_set_id", rewrite_rule_set_id)
        if rewrite_rule_set_name is not None:
            pulumi.set(__self__, "rewrite_rule_set_name", rewrite_rule_set_name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Name of the Path Rule.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def paths(self) -> List[str]:
        """
        A list of Paths used in this Path Rule.
        """
        return pulumi.get(self, "paths")

    @property
    @pulumi.getter(name="backendAddressPoolId")
    def backend_address_pool_id(self) -> Optional[str]:
        """
        The ID of the associated Backend Address Pool.
        """
        return pulumi.get(self, "backend_address_pool_id")

    @property
    @pulumi.getter(name="backendAddressPoolName")
    def backend_address_pool_name(self) -> Optional[str]:
        """
        The Name of the Backend Address Pool to use for this Path Rule. Cannot be set if `redirect_configuration_name` is set.
        """
        return pulumi.get(self, "backend_address_pool_name")

    @property
    @pulumi.getter(name="backendHttpSettingsId")
    def backend_http_settings_id(self) -> Optional[str]:
        """
        The ID of the associated Backend HTTP Settings Configuration.
        """
        return pulumi.get(self, "backend_http_settings_id")

    @property
    @pulumi.getter(name="backendHttpSettingsName")
    def backend_http_settings_name(self) -> Optional[str]:
        """
        The Name of the Backend HTTP Settings Collection to use for this Path Rule. Cannot be set if `redirect_configuration_name` is set.
        """
        return pulumi.get(self, "backend_http_settings_name")

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

    @property
    @pulumi.getter(name="redirectConfigurationId")
    def redirect_configuration_id(self) -> Optional[str]:
        """
        The ID of the associated Redirect Configuration.
        """
        return pulumi.get(self, "redirect_configuration_id")

    @property
    @pulumi.getter(name="redirectConfigurationName")
    def redirect_configuration_name(self) -> Optional[str]:
        """
        The Name of a Redirect Configuration to use for this Path Rule. Cannot be set if `backend_address_pool_name` or `backend_http_settings_name` is set.
        """
        return pulumi.get(self, "redirect_configuration_name")

    @property
    @pulumi.getter(name="rewriteRuleSetId")
    def rewrite_rule_set_id(self) -> Optional[str]:
        """
        The ID of the associated Rewrite Rule Set.
        """
        return pulumi.get(self, "rewrite_rule_set_id")

    @property
    @pulumi.getter(name="rewriteRuleSetName")
    def rewrite_rule_set_name(self) -> Optional[str]:
        """
        The Name of the Rewrite Rule Set which should be used for this URL Path Map. Only valid for v2 SKUs.
        """
        return pulumi.get(self, "rewrite_rule_set_name")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayWafConfiguration(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 firewall_mode: str,
                 rule_set_version: str,
                 disabled_rule_groups: Optional[List['outputs.ApplicationGatewayWafConfigurationDisabledRuleGroup']] = None,
                 exclusions: Optional[List['outputs.ApplicationGatewayWafConfigurationExclusion']] = None,
                 file_upload_limit_mb: Optional[float] = None,
                 max_request_body_size_kb: Optional[float] = None,
                 request_body_check: Optional[bool] = None,
                 rule_set_type: Optional[str] = None):
        """
        :param bool enabled: Is the Web Application Firewall be enabled?
        :param str firewall_mode: The Web Application Firewall Mode. Possible values are `Detection` and `Prevention`.
        :param str rule_set_version: The Version of the Rule Set used for this Web Application Firewall. Possible values are `2.2.9`, `3.0`, and `3.1`.
        :param List['ApplicationGatewayWafConfigurationDisabledRuleGroupArgs'] disabled_rule_groups: one or more `disabled_rule_group` blocks as defined below.
        :param List['ApplicationGatewayWafConfigurationExclusionArgs'] exclusions: one or more `exclusion` blocks as defined below.
        :param float file_upload_limit_mb: The File Upload Limit in MB. Accepted values are in the range `1`MB to `500`MB. Defaults to `100`MB.
        :param float max_request_body_size_kb: The Maximum Request Body Size in KB.  Accepted values are in the range `1`KB to `128`KB.  Defaults to `128`KB.
        :param bool request_body_check: Is Request Body Inspection enabled?  Defaults to `true`.
        :param str rule_set_type: The Type of the Rule Set used for this Web Application Firewall. Currently, only `OWASP` is supported.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "firewall_mode", firewall_mode)
        pulumi.set(__self__, "rule_set_version", rule_set_version)
        if disabled_rule_groups is not None:
            pulumi.set(__self__, "disabled_rule_groups", disabled_rule_groups)
        if exclusions is not None:
            pulumi.set(__self__, "exclusions", exclusions)
        if file_upload_limit_mb is not None:
            pulumi.set(__self__, "file_upload_limit_mb", file_upload_limit_mb)
        if max_request_body_size_kb is not None:
            pulumi.set(__self__, "max_request_body_size_kb", max_request_body_size_kb)
        if request_body_check is not None:
            pulumi.set(__self__, "request_body_check", request_body_check)
        if rule_set_type is not None:
            pulumi.set(__self__, "rule_set_type", rule_set_type)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Is the Web Application Firewall be enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="firewallMode")
    def firewall_mode(self) -> str:
        """
        The Web Application Firewall Mode. Possible values are `Detection` and `Prevention`.
        """
        return pulumi.get(self, "firewall_mode")

    @property
    @pulumi.getter(name="ruleSetVersion")
    def rule_set_version(self) -> str:
        """
        The Version of the Rule Set used for this Web Application Firewall. Possible values are `2.2.9`, `3.0`, and `3.1`.
        """
        return pulumi.get(self, "rule_set_version")

    @property
    @pulumi.getter(name="disabledRuleGroups")
    def disabled_rule_groups(self) -> Optional[List['outputs.ApplicationGatewayWafConfigurationDisabledRuleGroup']]:
        """
        one or more `disabled_rule_group` blocks as defined below.
        """
        return pulumi.get(self, "disabled_rule_groups")

    @property
    @pulumi.getter
    def exclusions(self) -> Optional[List['outputs.ApplicationGatewayWafConfigurationExclusion']]:
        """
        one or more `exclusion` blocks as defined below.
        """
        return pulumi.get(self, "exclusions")

    @property
    @pulumi.getter(name="fileUploadLimitMb")
    def file_upload_limit_mb(self) -> Optional[float]:
        """
        The File Upload Limit in MB. Accepted values are in the range `1`MB to `500`MB. Defaults to `100`MB.
        """
        return pulumi.get(self, "file_upload_limit_mb")

    @property
    @pulumi.getter(name="maxRequestBodySizeKb")
    def max_request_body_size_kb(self) -> Optional[float]:
        """
        The Maximum Request Body Size in KB.  Accepted values are in the range `1`KB to `128`KB.  Defaults to `128`KB.
        """
        return pulumi.get(self, "max_request_body_size_kb")

    @property
    @pulumi.getter(name="requestBodyCheck")
    def request_body_check(self) -> Optional[bool]:
        """
        Is Request Body Inspection enabled?  Defaults to `true`.
        """
        return pulumi.get(self, "request_body_check")

    @property
    @pulumi.getter(name="ruleSetType")
    def rule_set_type(self) -> Optional[str]:
        """
        The Type of the Rule Set used for this Web Application Firewall. Currently, only `OWASP` is supported.
        """
        return pulumi.get(self, "rule_set_type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayWafConfigurationDisabledRuleGroup(dict):
    def __init__(__self__, *,
                 rule_group_name: str,
                 rules: Optional[List[float]] = None):
        """
        :param str rule_group_name: The rule group where specific rules should be disabled. Accepted values are:  `crs_20_protocol_violations`, `crs_21_protocol_anomalies`, `crs_23_request_limits`, `crs_30_http_policy`, `crs_35_bad_robots`, `crs_40_generic_attacks`, `crs_41_sql_injection_attacks`, `crs_41_xss_attacks`, `crs_42_tight_security`, `crs_45_trojans`, `General`, `REQUEST-911-METHOD-ENFORCEMENT`, `REQUEST-913-SCANNER-DETECTION`, `REQUEST-920-PROTOCOL-ENFORCEMENT`, `REQUEST-921-PROTOCOL-ATTACK`, `REQUEST-930-APPLICATION-ATTACK-LFI`, `REQUEST-931-APPLICATION-ATTACK-RFI`, `REQUEST-932-APPLICATION-ATTACK-RCE`, `REQUEST-933-APPLICATION-ATTACK-PHP`, `REQUEST-941-APPLICATION-ATTACK-XSS`, `REQUEST-942-APPLICATION-ATTACK-SQLI`, `REQUEST-943-APPLICATION-ATTACK-SESSION-FIXATION`
        :param List[float] rules: A list of rules which should be disabled in that group. Disables all rules in the specified group if `rules` is not specified.
        """
        pulumi.set(__self__, "rule_group_name", rule_group_name)
        if rules is not None:
            pulumi.set(__self__, "rules", rules)

    @property
    @pulumi.getter(name="ruleGroupName")
    def rule_group_name(self) -> str:
        """
        The rule group where specific rules should be disabled. Accepted values are:  `crs_20_protocol_violations`, `crs_21_protocol_anomalies`, `crs_23_request_limits`, `crs_30_http_policy`, `crs_35_bad_robots`, `crs_40_generic_attacks`, `crs_41_sql_injection_attacks`, `crs_41_xss_attacks`, `crs_42_tight_security`, `crs_45_trojans`, `General`, `REQUEST-911-METHOD-ENFORCEMENT`, `REQUEST-913-SCANNER-DETECTION`, `REQUEST-920-PROTOCOL-ENFORCEMENT`, `REQUEST-921-PROTOCOL-ATTACK`, `REQUEST-930-APPLICATION-ATTACK-LFI`, `REQUEST-931-APPLICATION-ATTACK-RFI`, `REQUEST-932-APPLICATION-ATTACK-RCE`, `REQUEST-933-APPLICATION-ATTACK-PHP`, `REQUEST-941-APPLICATION-ATTACK-XSS`, `REQUEST-942-APPLICATION-ATTACK-SQLI`, `REQUEST-943-APPLICATION-ATTACK-SESSION-FIXATION`
        """
        return pulumi.get(self, "rule_group_name")

    @property
    @pulumi.getter
    def rules(self) -> Optional[List[float]]:
        """
        A list of rules which should be disabled in that group. Disables all rules in the specified group if `rules` is not specified.
        """
        return pulumi.get(self, "rules")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ApplicationGatewayWafConfigurationExclusion(dict):
    def __init__(__self__, *,
                 match_variable: str,
                 selector: Optional[str] = None,
                 selector_match_operator: Optional[str] = None):
        """
        :param str match_variable: Match variable of the exclusion rule to exclude header, cookie or GET arguments. Possible values are `RequestHeaderNames`, `RequestArgNames` and `RequestCookieNames`
        :param str selector: String value which will be used for the filter operation. If empty will exclude all traffic on this `match_variable`
        :param str selector_match_operator: Operator which will be used to search in the variable content. Possible values are `Equals`, `StartsWith`, `EndsWith`, `Contains`. If empty will exclude all traffic on this `match_variable`
        """
        pulumi.set(__self__, "match_variable", match_variable)
        if selector is not None:
            pulumi.set(__self__, "selector", selector)
        if selector_match_operator is not None:
            pulumi.set(__self__, "selector_match_operator", selector_match_operator)

    @property
    @pulumi.getter(name="matchVariable")
    def match_variable(self) -> str:
        """
        Match variable of the exclusion rule to exclude header, cookie or GET arguments. Possible values are `RequestHeaderNames`, `RequestArgNames` and `RequestCookieNames`
        """
        return pulumi.get(self, "match_variable")

    @property
    @pulumi.getter
    def selector(self) -> Optional[str]:
        """
        String value which will be used for the filter operation. If empty will exclude all traffic on this `match_variable`
        """
        return pulumi.get(self, "selector")

    @property
    @pulumi.getter(name="selectorMatchOperator")
    def selector_match_operator(self) -> Optional[str]:
        """
        Operator which will be used to search in the variable content. Possible values are `Equals`, `StartsWith`, `EndsWith`, `Contains`. If empty will exclude all traffic on this `match_variable`
        """
        return pulumi.get(self, "selector_match_operator")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ExpressRouteCircuitPeeringMicrosoftPeeringConfig(dict):
    def __init__(__self__, *,
                 advertised_public_prefixes: List[str],
                 customer_asn: Optional[float] = None,
                 routing_registry_name: Optional[str] = None):
        """
        :param List[str] advertised_public_prefixes: A list of Advertised Public Prefixes
        :param float customer_asn: The CustomerASN of the peering
        :param str routing_registry_name: The RoutingRegistryName of the configuration
        """
        pulumi.set(__self__, "advertised_public_prefixes", advertised_public_prefixes)
        if customer_asn is not None:
            pulumi.set(__self__, "customer_asn", customer_asn)
        if routing_registry_name is not None:
            pulumi.set(__self__, "routing_registry_name", routing_registry_name)

    @property
    @pulumi.getter(name="advertisedPublicPrefixes")
    def advertised_public_prefixes(self) -> List[str]:
        """
        A list of Advertised Public Prefixes
        """
        return pulumi.get(self, "advertised_public_prefixes")

    @property
    @pulumi.getter(name="customerAsn")
    def customer_asn(self) -> Optional[float]:
        """
        The CustomerASN of the peering
        """
        return pulumi.get(self, "customer_asn")

    @property
    @pulumi.getter(name="routingRegistryName")
    def routing_registry_name(self) -> Optional[str]:
        """
        The RoutingRegistryName of the configuration
        """
        return pulumi.get(self, "routing_registry_name")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ExpressRouteCircuitSku(dict):
    def __init__(__self__, *,
                 family: str,
                 tier: str):
        """
        :param str family: The billing mode for bandwidth. Possible values are `MeteredData` or `UnlimitedData`.
        :param str tier: The service tier. Possible values are `Basic`, `Local`, `Standard` or `Premium`.
        """
        pulumi.set(__self__, "family", family)
        pulumi.set(__self__, "tier", tier)

    @property
    @pulumi.getter
    def family(self) -> str:
        """
        The billing mode for bandwidth. Possible values are `MeteredData` or `UnlimitedData`.
        """
        return pulumi.get(self, "family")

    @property
    @pulumi.getter
    def tier(self) -> str:
        """
        The service tier. Possible values are `Basic`, `Local`, `Standard` or `Premium`.
        """
        return pulumi.get(self, "tier")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class FirewallApplicationRuleCollectionRule(dict):
    def __init__(__self__, *,
                 name: str,
                 source_addresses: List[str],
                 description: Optional[str] = None,
                 fqdn_tags: Optional[List[str]] = None,
                 protocols: Optional[List['outputs.FirewallApplicationRuleCollectionRuleProtocol']] = None,
                 target_fqdns: Optional[List[str]] = None):
        """
        :param str name: Specifies the name of the rule.
        :param List[str] source_addresses: A list of source IP addresses and/or IP ranges.
        :param str description: Specifies a description for the rule.
        :param List[str] fqdn_tags: A list of FQDN tags. Possible values are `AppServiceEnvironment`, `AzureBackup`, `AzureKubernetesService`, `HDInsight`, `MicrosoftActiveProtectionService`, `WindowsDiagnostics`, `WindowsUpdate` and `WindowsVirtualDesktop`.
        :param List['FirewallApplicationRuleCollectionRuleProtocolArgs'] protocols: One or more `protocol` blocks as defined below.
        :param List[str] target_fqdns: A list of FQDNs.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "source_addresses", source_addresses)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if fqdn_tags is not None:
            pulumi.set(__self__, "fqdn_tags", fqdn_tags)
        if protocols is not None:
            pulumi.set(__self__, "protocols", protocols)
        if target_fqdns is not None:
            pulumi.set(__self__, "target_fqdns", target_fqdns)

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

    @property
    @pulumi.getter(name="sourceAddresses")
    def source_addresses(self) -> List[str]:
        """
        A list of source IP addresses and/or IP ranges.
        """
        return pulumi.get(self, "source_addresses")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        Specifies a description for the rule.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="fqdnTags")
    def fqdn_tags(self) -> Optional[List[str]]:
        """
        A list of FQDN tags. Possible values are `AppServiceEnvironment`, `AzureBackup`, `AzureKubernetesService`, `HDInsight`, `MicrosoftActiveProtectionService`, `WindowsDiagnostics`, `WindowsUpdate` and `WindowsVirtualDesktop`.
        """
        return pulumi.get(self, "fqdn_tags")

    @property
    @pulumi.getter
    def protocols(self) -> Optional[List['outputs.FirewallApplicationRuleCollectionRuleProtocol']]:
        """
        One or more `protocol` blocks as defined below.
        """
        return pulumi.get(self, "protocols")

    @property
    @pulumi.getter(name="targetFqdns")
    def target_fqdns(self) -> Optional[List[str]]:
        """
        A list of FQDNs.
        """
        return pulumi.get(self, "target_fqdns")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class FirewallApplicationRuleCollectionRuleProtocol(dict):
    def __init__(__self__, *,
                 type: str,
                 port: Optional[float] = None):
        """
        :param str type: Specifies the type of connection. Possible values are `Http`, `Https` and `Mssql`.
        :param float port: Specify a port for the connection.
        """
        pulumi.set(__self__, "type", type)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Specifies the type of connection. Possible values are `Http`, `Https` and `Mssql`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def port(self) -> Optional[float]:
        """
        Specify a port for the connection.
        """
        return pulumi.get(self, "port")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class FirewallIpConfiguration(dict):
    def __init__(__self__, *,
                 name: str,
                 public_ip_address_id: str,
                 private_ip_address: Optional[str] = None,
                 subnet_id: Optional[str] = None):
        """
        :param str name: Specifies the name of the IP Configuration.
        :param str public_ip_address_id: The ID of the Public IP Address associated with the firewall.
        :param str private_ip_address: The Private IP address of the Azure Firewall.
        :param str subnet_id: Reference to the subnet associated with the IP Configuration.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "public_ip_address_id", public_ip_address_id)
        if private_ip_address is not None:
            pulumi.set(__self__, "private_ip_address", private_ip_address)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the IP Configuration.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="publicIpAddressId")
    def public_ip_address_id(self) -> str:
        """
        The ID of the Public IP Address associated with the firewall.
        """
        return pulumi.get(self, "public_ip_address_id")

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> Optional[str]:
        """
        The Private IP address of the Azure Firewall.
        """
        return pulumi.get(self, "private_ip_address")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        Reference to the subnet associated with the IP Configuration.
        """
        return pulumi.get(self, "subnet_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class FirewallManagementIpConfiguration(dict):
    def __init__(__self__, *,
                 name: str,
                 public_ip_address_id: str,
                 subnet_id: str,
                 private_ip_address: Optional[str] = None):
        """
        :param str name: Specifies the name of the IP Configuration.
        :param str public_ip_address_id: The ID of the Public IP Address associated with the firewall.
        :param str subnet_id: Reference to the subnet associated with the IP Configuration. Changing this forces a new resource to be created.
        :param str private_ip_address: The Private IP address of the Azure Firewall.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "public_ip_address_id", public_ip_address_id)
        pulumi.set(__self__, "subnet_id", subnet_id)
        if private_ip_address is not None:
            pulumi.set(__self__, "private_ip_address", private_ip_address)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the IP Configuration.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="publicIpAddressId")
    def public_ip_address_id(self) -> str:
        """
        The ID of the Public IP Address associated with the firewall.
        """
        return pulumi.get(self, "public_ip_address_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        Reference to the subnet associated with the IP Configuration. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> Optional[str]:
        """
        The Private IP address of the Azure Firewall.
        """
        return pulumi.get(self, "private_ip_address")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class FirewallNatRuleCollectionRule(dict):
    def __init__(__self__, *,
                 destination_addresses: List[str],
                 destination_ports: List[str],
                 name: str,
                 protocols: List[str],
                 source_addresses: List[str],
                 translated_address: str,
                 translated_port: str,
                 description: Optional[str] = None):
        """
        :param List[str] destination_addresses: A list of destination IP addresses and/or IP ranges.
        :param List[str] destination_ports: A list of destination ports.
        :param str name: Specifies the name of the rule.
        :param List[str] protocols: A list of protocols. Possible values are `Any`, `ICMP`, `TCP` and `UDP`.  If `action` is `Dnat`, protocols can only be `TCP` and `UDP`.
        :param List[str] source_addresses: A list of source IP addresses and/or IP ranges.
        :param str translated_address: The address of the service behind the Firewall.
        :param str translated_port: The port of the service behind the Firewall.
        :param str description: Specifies a description for the rule.
        """
        pulumi.set(__self__, "destination_addresses", destination_addresses)
        pulumi.set(__self__, "destination_ports", destination_ports)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "protocols", protocols)
        pulumi.set(__self__, "source_addresses", source_addresses)
        pulumi.set(__self__, "translated_address", translated_address)
        pulumi.set(__self__, "translated_port", translated_port)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter(name="destinationAddresses")
    def destination_addresses(self) -> List[str]:
        """
        A list of destination IP addresses and/or IP ranges.
        """
        return pulumi.get(self, "destination_addresses")

    @property
    @pulumi.getter(name="destinationPorts")
    def destination_ports(self) -> List[str]:
        """
        A list of destination ports.
        """
        return pulumi.get(self, "destination_ports")

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

    @property
    @pulumi.getter
    def protocols(self) -> List[str]:
        """
        A list of protocols. Possible values are `Any`, `ICMP`, `TCP` and `UDP`.  If `action` is `Dnat`, protocols can only be `TCP` and `UDP`.
        """
        return pulumi.get(self, "protocols")

    @property
    @pulumi.getter(name="sourceAddresses")
    def source_addresses(self) -> List[str]:
        """
        A list of source IP addresses and/or IP ranges.
        """
        return pulumi.get(self, "source_addresses")

    @property
    @pulumi.getter(name="translatedAddress")
    def translated_address(self) -> str:
        """
        The address of the service behind the Firewall.
        """
        return pulumi.get(self, "translated_address")

    @property
    @pulumi.getter(name="translatedPort")
    def translated_port(self) -> str:
        """
        The port of the service behind the Firewall.
        """
        return pulumi.get(self, "translated_port")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        Specifies a description for the rule.
        """
        return pulumi.get(self, "description")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class FirewallNetworkRuleCollectionRule(dict):
    def __init__(__self__, *,
                 destination_addresses: List[str],
                 destination_ports: List[str],
                 name: str,
                 protocols: List[str],
                 source_addresses: List[str],
                 description: Optional[str] = None):
        """
        :param List[str] destination_addresses: Either a list of destination IP addresses and/or IP ranges, or a list of destination [Service Tags](https://docs.microsoft.com/en-us/azure/virtual-network/service-tags-overview#available-service-tags).
        :param List[str] destination_ports: A list of destination ports.
        :param str name: Specifies the name of the rule.
        :param List[str] protocols: A list of protocols. Possible values are `Any`, `ICMP`, `TCP` and `UDP`.
        :param List[str] source_addresses: A list of source IP addresses and/or IP ranges.
        :param str description: Specifies a description for the rule.
        """
        pulumi.set(__self__, "destination_addresses", destination_addresses)
        pulumi.set(__self__, "destination_ports", destination_ports)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "protocols", protocols)
        pulumi.set(__self__, "source_addresses", source_addresses)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter(name="destinationAddresses")
    def destination_addresses(self) -> List[str]:
        """
        Either a list of destination IP addresses and/or IP ranges, or a list of destination [Service Tags](https://docs.microsoft.com/en-us/azure/virtual-network/service-tags-overview#available-service-tags).
        """
        return pulumi.get(self, "destination_addresses")

    @property
    @pulumi.getter(name="destinationPorts")
    def destination_ports(self) -> List[str]:
        """
        A list of destination ports.
        """
        return pulumi.get(self, "destination_ports")

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

    @property
    @pulumi.getter
    def protocols(self) -> List[str]:
        """
        A list of protocols. Possible values are `Any`, `ICMP`, `TCP` and `UDP`.
        """
        return pulumi.get(self, "protocols")

    @property
    @pulumi.getter(name="sourceAddresses")
    def source_addresses(self) -> List[str]:
        """
        A list of source IP addresses and/or IP ranges.
        """
        return pulumi.get(self, "source_addresses")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        Specifies a description for the rule.
        """
        return pulumi.get(self, "description")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class LocalNetworkGatewayBgpSettings(dict):
    def __init__(__self__, *,
                 asn: float,
                 bgp_peering_address: str,
                 peer_weight: Optional[float] = None):
        """
        :param float asn: The BGP speaker's ASN.
        :param str bgp_peering_address: The BGP peering address and BGP identifier
               of this BGP speaker.
        :param float peer_weight: The weight added to routes learned from this
               BGP speaker.
        """
        pulumi.set(__self__, "asn", asn)
        pulumi.set(__self__, "bgp_peering_address", bgp_peering_address)
        if peer_weight is not None:
            pulumi.set(__self__, "peer_weight", peer_weight)

    @property
    @pulumi.getter
    def asn(self) -> float:
        """
        The BGP speaker's ASN.
        """
        return pulumi.get(self, "asn")

    @property
    @pulumi.getter(name="bgpPeeringAddress")
    def bgp_peering_address(self) -> str:
        """
        The BGP peering address and BGP identifier
        of this BGP speaker.
        """
        return pulumi.get(self, "bgp_peering_address")

    @property
    @pulumi.getter(name="peerWeight")
    def peer_weight(self) -> Optional[float]:
        """
        The weight added to routes learned from this
        BGP speaker.
        """
        return pulumi.get(self, "peer_weight")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NetworkConnectionMonitorDestination(dict):
    def __init__(__self__, *,
                 port: float,
                 address: Optional[str] = None,
                 virtual_machine_id: Optional[str] = None):
        """
        :param float port: The destination port used by connection monitor.
        :param str address: The address of the connection monitor destination (IP or domain name). Conflicts with `destination.0.virtual_machine_id`
        :param str virtual_machine_id: The ID of the virtual machine used as the destination by connection monitor. Conflicts with `destination.0.address`
        """
        pulumi.set(__self__, "port", port)
        if address is not None:
            pulumi.set(__self__, "address", address)
        if virtual_machine_id is not None:
            pulumi.set(__self__, "virtual_machine_id", virtual_machine_id)

    @property
    @pulumi.getter
    def port(self) -> float:
        """
        The destination port used by connection monitor.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def address(self) -> Optional[str]:
        """
        The address of the connection monitor destination (IP or domain name). Conflicts with `destination.0.virtual_machine_id`
        """
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="virtualMachineId")
    def virtual_machine_id(self) -> Optional[str]:
        """
        The ID of the virtual machine used as the destination by connection monitor. Conflicts with `destination.0.address`
        """
        return pulumi.get(self, "virtual_machine_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NetworkConnectionMonitorSource(dict):
    def __init__(__self__, *,
                 virtual_machine_id: str,
                 port: Optional[float] = None):
        """
        :param str virtual_machine_id: The ID of the virtual machine used as the source by connection monitor.
        :param float port: The source port used by connection monitor.
        """
        pulumi.set(__self__, "virtual_machine_id", virtual_machine_id)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter(name="virtualMachineId")
    def virtual_machine_id(self) -> str:
        """
        The ID of the virtual machine used as the source by connection monitor.
        """
        return pulumi.get(self, "virtual_machine_id")

    @property
    @pulumi.getter
    def port(self) -> Optional[float]:
        """
        The source port used by connection monitor.
        """
        return pulumi.get(self, "port")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NetworkInterfaceIpConfiguration(dict):
    def __init__(__self__, *,
                 name: str,
                 private_ip_address_allocation: str,
                 primary: Optional[bool] = None,
                 private_ip_address: Optional[str] = None,
                 private_ip_address_version: Optional[str] = None,
                 public_ip_address_id: Optional[str] = None,
                 subnet_id: Optional[str] = None):
        """
        :param str name: A name used for this IP Configuration.
        :param str private_ip_address_allocation: The allocation method used for the Private IP Address. Possible values are `Dynamic` and `Static`.
        :param bool primary: Is this the Primary IP Configuration? Must be `true` for the first `ip_configuration` when multiple are specified. Defaults to `false`.
        :param str private_ip_address: The Static IP Address which should be used.
        :param str private_ip_address_version: The IP Version to use. Possible values are `IPv4` or `IPv6`. Defaults to `IPv4`.
        :param str public_ip_address_id: Reference to a Public IP Address to associate with this NIC
        :param str subnet_id: The ID of the Subnet where this Network Interface should be located in.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "private_ip_address_allocation", private_ip_address_allocation)
        if primary is not None:
            pulumi.set(__self__, "primary", primary)
        if private_ip_address is not None:
            pulumi.set(__self__, "private_ip_address", private_ip_address)
        if private_ip_address_version is not None:
            pulumi.set(__self__, "private_ip_address_version", private_ip_address_version)
        if public_ip_address_id is not None:
            pulumi.set(__self__, "public_ip_address_id", public_ip_address_id)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A name used for this IP Configuration.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="privateIpAddressAllocation")
    def private_ip_address_allocation(self) -> str:
        """
        The allocation method used for the Private IP Address. Possible values are `Dynamic` and `Static`.
        """
        return pulumi.get(self, "private_ip_address_allocation")

    @property
    @pulumi.getter
    def primary(self) -> Optional[bool]:
        """
        Is this the Primary IP Configuration? Must be `true` for the first `ip_configuration` when multiple are specified. Defaults to `false`.
        """
        return pulumi.get(self, "primary")

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> Optional[str]:
        """
        The Static IP Address which should be used.
        """
        return pulumi.get(self, "private_ip_address")

    @property
    @pulumi.getter(name="privateIpAddressVersion")
    def private_ip_address_version(self) -> Optional[str]:
        """
        The IP Version to use. Possible values are `IPv4` or `IPv6`. Defaults to `IPv4`.
        """
        return pulumi.get(self, "private_ip_address_version")

    @property
    @pulumi.getter(name="publicIpAddressId")
    def public_ip_address_id(self) -> Optional[str]:
        """
        Reference to a Public IP Address to associate with this NIC
        """
        return pulumi.get(self, "public_ip_address_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        """
        The ID of the Subnet where this Network Interface should be located in.
        """
        return pulumi.get(self, "subnet_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NetworkPacketCaptureFilter(dict):
    def __init__(__self__, *,
                 protocol: str,
                 local_ip_address: Optional[str] = None,
                 local_port: Optional[str] = None,
                 remote_ip_address: Optional[str] = None,
                 remote_port: Optional[str] = None):
        """
        :param str protocol: The Protocol to be filtered on. Possible values include `Any`, `TCP` and `UDP`. Changing this forces a new resource to be created.
        :param str local_ip_address: The local IP Address to be filtered on. Notation: "127.0.0.1" for single address entry. "127.0.0.1-127.0.0.255" for range. "127.0.0.1;127.0.0.5" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Changing this forces a new resource to be created.
        :param str local_port: The local port to be filtered on. Notation: "80" for single port entry."80-85" for range. "80;443;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Changing this forces a new resource to be created.
        :param str remote_ip_address: The remote IP Address to be filtered on. Notation: "127.0.0.1" for single address entry. "127.0.0.1-127.0.0.255" for range. "127.0.0.1;127.0.0.5;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported.. Changing this forces a new resource to be created.
        :param str remote_port: The remote port to be filtered on. Notation: "80" for single port entry."80-85" for range. "80;443;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "protocol", protocol)
        if local_ip_address is not None:
            pulumi.set(__self__, "local_ip_address", local_ip_address)
        if local_port is not None:
            pulumi.set(__self__, "local_port", local_port)
        if remote_ip_address is not None:
            pulumi.set(__self__, "remote_ip_address", remote_ip_address)
        if remote_port is not None:
            pulumi.set(__self__, "remote_port", remote_port)

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The Protocol to be filtered on. Possible values include `Any`, `TCP` and `UDP`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="localIpAddress")
    def local_ip_address(self) -> Optional[str]:
        """
        The local IP Address to be filtered on. Notation: "127.0.0.1" for single address entry. "127.0.0.1-127.0.0.255" for range. "127.0.0.1;127.0.0.5" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "local_ip_address")

    @property
    @pulumi.getter(name="localPort")
    def local_port(self) -> Optional[str]:
        """
        The local port to be filtered on. Notation: "80" for single port entry."80-85" for range. "80;443;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "local_port")

    @property
    @pulumi.getter(name="remoteIpAddress")
    def remote_ip_address(self) -> Optional[str]:
        """
        The remote IP Address to be filtered on. Notation: "127.0.0.1" for single address entry. "127.0.0.1-127.0.0.255" for range. "127.0.0.1;127.0.0.5;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported.. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "remote_ip_address")

    @property
    @pulumi.getter(name="remotePort")
    def remote_port(self) -> Optional[str]:
        """
        The remote port to be filtered on. Notation: "80" for single port entry."80-85" for range. "80;443;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "remote_port")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NetworkPacketCaptureStorageLocation(dict):
    def __init__(__self__, *,
                 file_path: Optional[str] = None,
                 storage_account_id: Optional[str] = None,
                 storage_path: Optional[str] = None):
        """
        :param str file_path: A valid local path on the targeting VM. Must include the name of the capture file (*.cap). For linux virtual machine it must start with `/var/captures`.
        :param str storage_account_id: The ID of the storage account to save the packet capture session
        :param str storage_path: The URI of the storage path to save the packet capture.
        """
        if file_path is not None:
            pulumi.set(__self__, "file_path", file_path)
        if storage_account_id is not None:
            pulumi.set(__self__, "storage_account_id", storage_account_id)
        if storage_path is not None:
            pulumi.set(__self__, "storage_path", storage_path)

    @property
    @pulumi.getter(name="filePath")
    def file_path(self) -> Optional[str]:
        """
        A valid local path on the targeting VM. Must include the name of the capture file (*.cap). For linux virtual machine it must start with `/var/captures`.
        """
        return pulumi.get(self, "file_path")

    @property
    @pulumi.getter(name="storageAccountId")
    def storage_account_id(self) -> Optional[str]:
        """
        The ID of the storage account to save the packet capture session
        """
        return pulumi.get(self, "storage_account_id")

    @property
    @pulumi.getter(name="storagePath")
    def storage_path(self) -> Optional[str]:
        """
        The URI of the storage path to save the packet capture.
        """
        return pulumi.get(self, "storage_path")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NetworkSecurityGroupSecurityRule(dict):
    def __init__(__self__, *,
                 access: str,
                 direction: str,
                 name: str,
                 priority: float,
                 protocol: str,
                 description: Optional[str] = None,
                 destination_address_prefix: Optional[str] = None,
                 destination_address_prefixes: Optional[List[str]] = None,
                 destination_application_security_group_ids: Optional[List[str]] = None,
                 destination_port_range: Optional[str] = None,
                 destination_port_ranges: Optional[List[str]] = None,
                 source_address_prefix: Optional[str] = None,
                 source_address_prefixes: Optional[List[str]] = None,
                 source_application_security_group_ids: Optional[List[str]] = None,
                 source_port_range: Optional[str] = None,
                 source_port_ranges: Optional[List[str]] = None):
        """
        :param str access: Specifies whether network traffic is allowed or denied. Possible values are `Allow` and `Deny`.
        :param str direction: The direction specifies if rule will be evaluated on incoming or outgoing traffic. Possible values are `Inbound` and `Outbound`.
        :param str name: The name of the security rule.
        :param float priority: Specifies the priority of the rule. The value can be between 100 and 4096. The priority number must be unique for each rule in the collection. The lower the priority number, the higher the priority of the rule.
        :param str protocol: Network protocol this rule applies to. Can be `Tcp`, `Udp`, `Icmp`, or `*` to match all.
        :param str description: A description for this rule. Restricted to 140 characters.
        :param str destination_address_prefix: CIDR or destination IP range or * to match any IP. Tags such as ‘VirtualNetwork’, ‘AzureLoadBalancer’ and ‘Internet’ can also be used. This is required if `destination_address_prefixes` is not specified.
        :param List[str] destination_address_prefixes: List of destination address prefixes. Tags may not be used. This is required if `destination_address_prefix` is not specified.
        :param List[str] destination_application_security_group_ids: A List of destination Application Security Group ID's
        :param str destination_port_range: Destination Port or Range. Integer or range between `0` and `65535` or `*` to match any. This is required if `destination_port_ranges` is not specified.
        :param List[str] destination_port_ranges: List of destination ports or port ranges. This is required if `destination_port_range` is not specified.
        :param str source_address_prefix: CIDR or source IP range or * to match any IP. Tags such as ‘VirtualNetwork’, ‘AzureLoadBalancer’ and ‘Internet’ can also be used. This is required if `source_address_prefixes` is not specified.
        :param List[str] source_address_prefixes: List of source address prefixes. Tags may not be used. This is required if `source_address_prefix` is not specified.
        :param List[str] source_application_security_group_ids: A List of source Application Security Group ID's
        :param str source_port_range: Source Port or Range. Integer or range between `0` and `65535` or `*` to match any. This is required if `source_port_ranges` is not specified.
        :param List[str] source_port_ranges: List of source ports or port ranges. This is required if `source_port_range` is not specified.
        """
        pulumi.set(__self__, "access", access)
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "protocol", protocol)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if destination_address_prefix is not None:
            pulumi.set(__self__, "destination_address_prefix", destination_address_prefix)
        if destination_address_prefixes is not None:
            pulumi.set(__self__, "destination_address_prefixes", destination_address_prefixes)
        if destination_application_security_group_ids is not None:
            pulumi.set(__self__, "destination_application_security_group_ids", destination_application_security_group_ids)
        if destination_port_range is not None:
            pulumi.set(__self__, "destination_port_range", destination_port_range)
        if destination_port_ranges is not None:
            pulumi.set(__self__, "destination_port_ranges", destination_port_ranges)
        if source_address_prefix is not None:
            pulumi.set(__self__, "source_address_prefix", source_address_prefix)
        if source_address_prefixes is not None:
            pulumi.set(__self__, "source_address_prefixes", source_address_prefixes)
        if source_application_security_group_ids is not None:
            pulumi.set(__self__, "source_application_security_group_ids", source_application_security_group_ids)
        if source_port_range is not None:
            pulumi.set(__self__, "source_port_range", source_port_range)
        if source_port_ranges is not None:
            pulumi.set(__self__, "source_port_ranges", source_port_ranges)

    @property
    @pulumi.getter
    def access(self) -> str:
        """
        Specifies whether network traffic is allowed or denied. Possible values are `Allow` and `Deny`.
        """
        return pulumi.get(self, "access")

    @property
    @pulumi.getter
    def direction(self) -> str:
        """
        The direction specifies if rule will be evaluated on incoming or outgoing traffic. Possible values are `Inbound` and `Outbound`.
        """
        return pulumi.get(self, "direction")

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

    @property
    @pulumi.getter
    def priority(self) -> float:
        """
        Specifies the priority of the rule. The value can be between 100 and 4096. The priority number must be unique for each rule in the collection. The lower the priority number, the higher the priority of the rule.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        Network protocol this rule applies to. Can be `Tcp`, `Udp`, `Icmp`, or `*` to match all.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        A description for this rule. Restricted to 140 characters.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="destinationAddressPrefix")
    def destination_address_prefix(self) -> Optional[str]:
        """
        CIDR or destination IP range or * to match any IP. Tags such as ‘VirtualNetwork’, ‘AzureLoadBalancer’ and ‘Internet’ can also be used. This is required if `destination_address_prefixes` is not specified.
        """
        return pulumi.get(self, "destination_address_prefix")

    @property
    @pulumi.getter(name="destinationAddressPrefixes")
    def destination_address_prefixes(self) -> Optional[List[str]]:
        """
        List of destination address prefixes. Tags may not be used. This is required if `destination_address_prefix` is not specified.
        """
        return pulumi.get(self, "destination_address_prefixes")

    @property
    @pulumi.getter(name="destinationApplicationSecurityGroupIds")
    def destination_application_security_group_ids(self) -> Optional[List[str]]:
        """
        A List of destination Application Security Group ID's
        """
        return pulumi.get(self, "destination_application_security_group_ids")

    @property
    @pulumi.getter(name="destinationPortRange")
    def destination_port_range(self) -> Optional[str]:
        """
        Destination Port or Range. Integer or range between `0` and `65535` or `*` to match any. This is required if `destination_port_ranges` is not specified.
        """
        return pulumi.get(self, "destination_port_range")

    @property
    @pulumi.getter(name="destinationPortRanges")
    def destination_port_ranges(self) -> Optional[List[str]]:
        """
        List of destination ports or port ranges. This is required if `destination_port_range` is not specified.
        """
        return pulumi.get(self, "destination_port_ranges")

    @property
    @pulumi.getter(name="sourceAddressPrefix")
    def source_address_prefix(self) -> Optional[str]:
        """
        CIDR or source IP range or * to match any IP. Tags such as ‘VirtualNetwork’, ‘AzureLoadBalancer’ and ‘Internet’ can also be used. This is required if `source_address_prefixes` is not specified.
        """
        return pulumi.get(self, "source_address_prefix")

    @property
    @pulumi.getter(name="sourceAddressPrefixes")
    def source_address_prefixes(self) -> Optional[List[str]]:
        """
        List of source address prefixes. Tags may not be used. This is required if `source_address_prefix` is not specified.
        """
        return pulumi.get(self, "source_address_prefixes")

    @property
    @pulumi.getter(name="sourceApplicationSecurityGroupIds")
    def source_application_security_group_ids(self) -> Optional[List[str]]:
        """
        A List of source Application Security Group ID's
        """
        return pulumi.get(self, "source_application_security_group_ids")

    @property
    @pulumi.getter(name="sourcePortRange")
    def source_port_range(self) -> Optional[str]:
        """
        Source Port or Range. Integer or range between `0` and `65535` or `*` to match any. This is required if `source_port_ranges` is not specified.
        """
        return pulumi.get(self, "source_port_range")

    @property
    @pulumi.getter(name="sourcePortRanges")
    def source_port_ranges(self) -> Optional[List[str]]:
        """
        List of source ports or port ranges. This is required if `source_port_range` is not specified.
        """
        return pulumi.get(self, "source_port_ranges")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NetworkWatcherFlowLogRetentionPolicy(dict):
    def __init__(__self__, *,
                 days: float,
                 enabled: bool):
        """
        :param float days: The number of days to retain flow log records.
        :param bool enabled: Boolean flag to enable/disable traffic analytics.
        """
        pulumi.set(__self__, "days", days)
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def days(self) -> float:
        """
        The number of days to retain flow log records.
        """
        return pulumi.get(self, "days")

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Boolean flag to enable/disable traffic analytics.
        """
        return pulumi.get(self, "enabled")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class NetworkWatcherFlowLogTrafficAnalytics(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 workspace_id: str,
                 workspace_region: str,
                 workspace_resource_id: str,
                 interval_in_minutes: Optional[float] = None):
        """
        :param bool enabled: Boolean flag to enable/disable traffic analytics.
        :param str workspace_id: The resource guid of the attached workspace.
        :param str workspace_region: The location of the attached workspace.
        :param str workspace_resource_id: The resource ID of the attached workspace.
        :param float interval_in_minutes: How frequently service should do flow analytics in minutes.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "workspace_id", workspace_id)
        pulumi.set(__self__, "workspace_region", workspace_region)
        pulumi.set(__self__, "workspace_resource_id", workspace_resource_id)
        if interval_in_minutes is not None:
            pulumi.set(__self__, "interval_in_minutes", interval_in_minutes)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Boolean flag to enable/disable traffic analytics.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="workspaceId")
    def workspace_id(self) -> str:
        """
        The resource guid of the attached workspace.
        """
        return pulumi.get(self, "workspace_id")

    @property
    @pulumi.getter(name="workspaceRegion")
    def workspace_region(self) -> str:
        """
        The location of the attached workspace.
        """
        return pulumi.get(self, "workspace_region")

    @property
    @pulumi.getter(name="workspaceResourceId")
    def workspace_resource_id(self) -> str:
        """
        The resource ID of the attached workspace.
        """
        return pulumi.get(self, "workspace_resource_id")

    @property
    @pulumi.getter(name="intervalInMinutes")
    def interval_in_minutes(self) -> Optional[float]:
        """
        How frequently service should do flow analytics in minutes.
        """
        return pulumi.get(self, "interval_in_minutes")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PacketCaptureFilter(dict):
    def __init__(__self__, *,
                 protocol: str,
                 local_ip_address: Optional[str] = None,
                 local_port: Optional[str] = None,
                 remote_ip_address: Optional[str] = None,
                 remote_port: Optional[str] = None):
        """
        :param str protocol: The Protocol to be filtered on. Possible values include `Any`, `TCP` and `UDP`. Changing this forces a new resource to be created.
        :param str local_ip_address: The local IP Address to be filtered on. Notation: "127.0.0.1" for single address entry. "127.0.0.1-127.0.0.255" for range. "127.0.0.1;127.0.0.5" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Changing this forces a new resource to be created.
        :param str local_port: The local port to be filtered on. Notation: "80" for single port entry."80-85" for range. "80;443;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Changing this forces a new resource to be created.
        :param str remote_ip_address: The remote IP Address to be filtered on. Notation: "127.0.0.1" for single address entry. "127.0.0.1-127.0.0.255" for range. "127.0.0.1;127.0.0.5;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported.. Changing this forces a new resource to be created.
        :param str remote_port: The remote port to be filtered on. Notation: "80" for single port entry."80-85" for range. "80;443;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "protocol", protocol)
        if local_ip_address is not None:
            pulumi.set(__self__, "local_ip_address", local_ip_address)
        if local_port is not None:
            pulumi.set(__self__, "local_port", local_port)
        if remote_ip_address is not None:
            pulumi.set(__self__, "remote_ip_address", remote_ip_address)
        if remote_port is not None:
            pulumi.set(__self__, "remote_port", remote_port)

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The Protocol to be filtered on. Possible values include `Any`, `TCP` and `UDP`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="localIpAddress")
    def local_ip_address(self) -> Optional[str]:
        """
        The local IP Address to be filtered on. Notation: "127.0.0.1" for single address entry. "127.0.0.1-127.0.0.255" for range. "127.0.0.1;127.0.0.5" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "local_ip_address")

    @property
    @pulumi.getter(name="localPort")
    def local_port(self) -> Optional[str]:
        """
        The local port to be filtered on. Notation: "80" for single port entry."80-85" for range. "80;443;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "local_port")

    @property
    @pulumi.getter(name="remoteIpAddress")
    def remote_ip_address(self) -> Optional[str]:
        """
        The remote IP Address to be filtered on. Notation: "127.0.0.1" for single address entry. "127.0.0.1-127.0.0.255" for range. "127.0.0.1;127.0.0.5;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported.. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "remote_ip_address")

    @property
    @pulumi.getter(name="remotePort")
    def remote_port(self) -> Optional[str]:
        """
        The remote port to be filtered on. Notation: "80" for single port entry."80-85" for range. "80;443;" for multiple entries. Multiple ranges not currently supported. Mixing ranges with multiple entries not currently supported. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "remote_port")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PacketCaptureStorageLocation(dict):
    def __init__(__self__, *,
                 file_path: Optional[str] = None,
                 storage_account_id: Optional[str] = None,
                 storage_path: Optional[str] = None):
        """
        :param str file_path: A valid local path on the targeting VM. Must include the name of the capture file (*.cap). For linux virtual machine it must start with `/var/captures`.
        :param str storage_account_id: The ID of the storage account to save the packet capture session
        :param str storage_path: The URI of the storage path to save the packet capture.
        """
        if file_path is not None:
            pulumi.set(__self__, "file_path", file_path)
        if storage_account_id is not None:
            pulumi.set(__self__, "storage_account_id", storage_account_id)
        if storage_path is not None:
            pulumi.set(__self__, "storage_path", storage_path)

    @property
    @pulumi.getter(name="filePath")
    def file_path(self) -> Optional[str]:
        """
        A valid local path on the targeting VM. Must include the name of the capture file (*.cap). For linux virtual machine it must start with `/var/captures`.
        """
        return pulumi.get(self, "file_path")

    @property
    @pulumi.getter(name="storageAccountId")
    def storage_account_id(self) -> Optional[str]:
        """
        The ID of the storage account to save the packet capture session
        """
        return pulumi.get(self, "storage_account_id")

    @property
    @pulumi.getter(name="storagePath")
    def storage_path(self) -> Optional[str]:
        """
        The URI of the storage path to save the packet capture.
        """
        return pulumi.get(self, "storage_path")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PointToPointVpnGatewayConnectionConfiguration(dict):
    def __init__(__self__, *,
                 name: str,
                 vpn_client_address_pool: 'outputs.PointToPointVpnGatewayConnectionConfigurationVpnClientAddressPool'):
        """
        :param str name: The Name which should be used for this Connection Configuration.
        :param 'PointToPointVpnGatewayConnectionConfigurationVpnClientAddressPoolArgs' vpn_client_address_pool: A `vpn_client_address_pool` block as defined below.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "vpn_client_address_pool", vpn_client_address_pool)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Name which should be used for this Connection Configuration.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="vpnClientAddressPool")
    def vpn_client_address_pool(self) -> 'outputs.PointToPointVpnGatewayConnectionConfigurationVpnClientAddressPool':
        """
        A `vpn_client_address_pool` block as defined below.
        """
        return pulumi.get(self, "vpn_client_address_pool")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class PointToPointVpnGatewayConnectionConfigurationVpnClientAddressPool(dict):
    def __init__(__self__, *,
                 address_prefixes: List[str]):
        """
        :param List[str] address_prefixes: A list of CIDR Ranges which should be used as Address Prefixes.
        """
        pulumi.set(__self__, "address_prefixes", address_prefixes)

    @property
    @pulumi.getter(name="addressPrefixes")
    def address_prefixes(self) -> List[str]:
        """
        A list of CIDR Ranges which should be used as Address Prefixes.
        """
        return pulumi.get(self, "address_prefixes")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ProfileContainerNetworkInterface(dict):
    def __init__(__self__, *,
                 ip_configurations: List['outputs.ProfileContainerNetworkInterfaceIpConfiguration'],
                 name: str):
        """
        :param List['ProfileContainerNetworkInterfaceIpConfigurationArgs'] ip_configurations: One or more `ip_configuration` blocks as documented below.
        :param str name: Specifies the name of the IP Configuration.
        """
        pulumi.set(__self__, "ip_configurations", ip_configurations)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="ipConfigurations")
    def ip_configurations(self) -> List['outputs.ProfileContainerNetworkInterfaceIpConfiguration']:
        """
        One or more `ip_configuration` blocks as documented below.
        """
        return pulumi.get(self, "ip_configurations")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the IP Configuration.
        """
        return pulumi.get(self, "name")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ProfileContainerNetworkInterfaceIpConfiguration(dict):
    def __init__(__self__, *,
                 name: str,
                 subnet_id: str):
        """
        :param str name: Specifies the name of the IP Configuration.
        :param str subnet_id: Reference to the subnet associated with the IP Configuration.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the IP Configuration.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        Reference to the subnet associated with the IP Configuration.
        """
        return pulumi.get(self, "subnet_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class RouteFilterRule(dict):
    def __init__(__self__, *,
                 access: str,
                 communities: List[str],
                 name: str,
                 rule_type: str):
        """
        :param str access: The access type of the rule. The only possible value is `Allow`.
        :param List[str] communities: The collection for bgp community values to filter on. e.g. ['12076:5010','12076:5020'].
        :param str name: The name of the route filter rule.
        :param str rule_type: The rule type of the rule. The only possible value is `Community`.
        """
        pulumi.set(__self__, "access", access)
        pulumi.set(__self__, "communities", communities)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "rule_type", rule_type)

    @property
    @pulumi.getter
    def access(self) -> str:
        """
        The access type of the rule. The only possible value is `Allow`.
        """
        return pulumi.get(self, "access")

    @property
    @pulumi.getter
    def communities(self) -> List[str]:
        """
        The collection for bgp community values to filter on. e.g. ['12076:5010','12076:5020'].
        """
        return pulumi.get(self, "communities")

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

    @property
    @pulumi.getter(name="ruleType")
    def rule_type(self) -> str:
        """
        The rule type of the rule. The only possible value is `Community`.
        """
        return pulumi.get(self, "rule_type")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class RouteTableRoute(dict):
    def __init__(__self__, *,
                 address_prefix: str,
                 name: str,
                 next_hop_type: str,
                 next_hop_in_ip_address: Optional[str] = None):
        """
        :param str address_prefix: The destination CIDR to which the route applies, such as 10.1.0.0/16
        :param str name: The name of the route.
        :param str next_hop_type: The type of Azure hop the packet should be sent to. Possible values are `VirtualNetworkGateway`, `VnetLocal`, `Internet`, `VirtualAppliance` and `None`.
        :param str next_hop_in_ip_address: Contains the IP address packets should be forwarded to. Next hop values are only allowed in routes where the next hop type is `VirtualAppliance`.
        """
        pulumi.set(__self__, "address_prefix", address_prefix)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "next_hop_type", next_hop_type)
        if next_hop_in_ip_address is not None:
            pulumi.set(__self__, "next_hop_in_ip_address", next_hop_in_ip_address)

    @property
    @pulumi.getter(name="addressPrefix")
    def address_prefix(self) -> str:
        """
        The destination CIDR to which the route applies, such as 10.1.0.0/16
        """
        return pulumi.get(self, "address_prefix")

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

    @property
    @pulumi.getter(name="nextHopType")
    def next_hop_type(self) -> str:
        """
        The type of Azure hop the packet should be sent to. Possible values are `VirtualNetworkGateway`, `VnetLocal`, `Internet`, `VirtualAppliance` and `None`.
        """
        return pulumi.get(self, "next_hop_type")

    @property
    @pulumi.getter(name="nextHopInIpAddress")
    def next_hop_in_ip_address(self) -> Optional[str]:
        """
        Contains the IP address packets should be forwarded to. Next hop values are only allowed in routes where the next hop type is `VirtualAppliance`.
        """
        return pulumi.get(self, "next_hop_in_ip_address")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class SubnetDelegation(dict):
    def __init__(__self__, *,
                 name: str,
                 service_delegation: 'outputs.SubnetDelegationServiceDelegation'):
        """
        :param str name: A name for this delegation.
        :param 'SubnetDelegationServiceDelegationArgs' service_delegation: A `service_delegation` block as defined below.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "service_delegation", service_delegation)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A name for this delegation.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="serviceDelegation")
    def service_delegation(self) -> 'outputs.SubnetDelegationServiceDelegation':
        """
        A `service_delegation` block as defined below.
        """
        return pulumi.get(self, "service_delegation")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class SubnetDelegationServiceDelegation(dict):
    def __init__(__self__, *,
                 name: str,
                 actions: Optional[List[str]] = None):
        """
        :param str name: The name of service to delegate to. Possible values include `Microsoft.ApiManagement/service`, `Microsoft.AzureCosmosDB/clusters`, `Microsoft.BareMetal/AzureVMware`, `Microsoft.BareMetal/CrayServers`, `Microsoft.Batch/batchAccounts`, `Microsoft.ContainerInstance/containerGroups`, `Microsoft.Databricks/workspaces`, `Microsoft.DBforMySQL/flexibleServers`, `Microsoft.DBforMySQL/serversv2`, `Microsoft.DBforPostgreSQL/flexibleServers`, `Microsoft.DBforPostgreSQL/serversv2`, `Microsoft.DBforPostgreSQL/singleServers`, `Microsoft.HardwareSecurityModules/dedicatedHSMs`, `Microsoft.Kusto/clusters`, `Microsoft.Logic/integrationServiceEnvironments`, `Microsoft.MachineLearningServices/workspaces`,  `Microsoft.Netapp/volumes`, `Microsoft.Network/managedResolvers`, `Microsoft.PowerPlatform/vnetaccesslinks`, `Microsoft.ServiceFabricMesh/networks`, `Microsoft.Sql/managedInstances`, `Microsoft.Sql/servers`, `Microsoft.StreamAnalytics/streamingJobs`, `Microsoft.Synapse/workspaces`, `Microsoft.Web/hostingEnvironments`, and `Microsoft.Web/serverFarms`.
        :param List[str] actions: A list of Actions which should be delegated. This list is specific to the service to delegate to. Possible values include `Microsoft.Network/networkinterfaces/*`, `Microsoft.Network/virtualNetworks/subnets/action`, `Microsoft.Network/virtualNetworks/subnets/join/action`, `Microsoft.Network/virtualNetworks/subnets/prepareNetworkPolicies/action` and `Microsoft.Network/virtualNetworks/subnets/unprepareNetworkPolicies/action`.
        """
        pulumi.set(__self__, "name", name)
        if actions is not None:
            pulumi.set(__self__, "actions", actions)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of service to delegate to. Possible values include `Microsoft.ApiManagement/service`, `Microsoft.AzureCosmosDB/clusters`, `Microsoft.BareMetal/AzureVMware`, `Microsoft.BareMetal/CrayServers`, `Microsoft.Batch/batchAccounts`, `Microsoft.ContainerInstance/containerGroups`, `Microsoft.Databricks/workspaces`, `Microsoft.DBforMySQL/flexibleServers`, `Microsoft.DBforMySQL/serversv2`, `Microsoft.DBforPostgreSQL/flexibleServers`, `Microsoft.DBforPostgreSQL/serversv2`, `Microsoft.DBforPostgreSQL/singleServers`, `Microsoft.HardwareSecurityModules/dedicatedHSMs`, `Microsoft.Kusto/clusters`, `Microsoft.Logic/integrationServiceEnvironments`, `Microsoft.MachineLearningServices/workspaces`,  `Microsoft.Netapp/volumes`, `Microsoft.Network/managedResolvers`, `Microsoft.PowerPlatform/vnetaccesslinks`, `Microsoft.ServiceFabricMesh/networks`, `Microsoft.Sql/managedInstances`, `Microsoft.Sql/servers`, `Microsoft.StreamAnalytics/streamingJobs`, `Microsoft.Synapse/workspaces`, `Microsoft.Web/hostingEnvironments`, and `Microsoft.Web/serverFarms`.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def actions(self) -> Optional[List[str]]:
        """
        A list of Actions which should be delegated. This list is specific to the service to delegate to. Possible values include `Microsoft.Network/networkinterfaces/*`, `Microsoft.Network/virtualNetworks/subnets/action`, `Microsoft.Network/virtualNetworks/subnets/join/action`, `Microsoft.Network/virtualNetworks/subnets/prepareNetworkPolicies/action` and `Microsoft.Network/virtualNetworks/subnets/unprepareNetworkPolicies/action`.
        """
        return pulumi.get(self, "actions")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class TrafficManagerEndpointCustomHeader(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The name of the custom header.
        :param str value: The value of custom header. Applicable for Http and Https protocol.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the custom header.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The value of custom header. Applicable for Http and Https protocol.
        """
        return pulumi.get(self, "value")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class TrafficManagerEndpointSubnet(dict):
    def __init__(__self__, *,
                 first: str,
                 last: Optional[str] = None,
                 scope: Optional[float] = None):
        """
        :param str first: The First IP....
        :param str last: The Last IP...
        :param float scope: The Scope...
        """
        pulumi.set(__self__, "first", first)
        if last is not None:
            pulumi.set(__self__, "last", last)
        if scope is not None:
            pulumi.set(__self__, "scope", scope)

    @property
    @pulumi.getter
    def first(self) -> str:
        """
        The First IP....
        """
        return pulumi.get(self, "first")

    @property
    @pulumi.getter
    def last(self) -> Optional[str]:
        """
        The Last IP...
        """
        return pulumi.get(self, "last")

    @property
    @pulumi.getter
    def scope(self) -> Optional[float]:
        """
        The Scope...
        """
        return pulumi.get(self, "scope")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class TrafficManagerProfileDnsConfig(dict):
    def __init__(__self__, *,
                 relative_name: str,
                 ttl: float):
        """
        :param str relative_name: The relative domain name, this is combined with the domain name used by Traffic Manager to form the FQDN which is exported as documented below. Changing this forces a new resource to be created.
        :param float ttl: The TTL value of the Profile used by Local DNS resolvers and clients.
        """
        pulumi.set(__self__, "relative_name", relative_name)
        pulumi.set(__self__, "ttl", ttl)

    @property
    @pulumi.getter(name="relativeName")
    def relative_name(self) -> str:
        """
        The relative domain name, this is combined with the domain name used by Traffic Manager to form the FQDN which is exported as documented below. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "relative_name")

    @property
    @pulumi.getter
    def ttl(self) -> float:
        """
        The TTL value of the Profile used by Local DNS resolvers and clients.
        """
        return pulumi.get(self, "ttl")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class TrafficManagerProfileMonitorConfig(dict):
    def __init__(__self__, *,
                 port: float,
                 protocol: str,
                 custom_headers: Optional[List['outputs.TrafficManagerProfileMonitorConfigCustomHeader']] = None,
                 expected_status_code_ranges: Optional[List[str]] = None,
                 interval_in_seconds: Optional[float] = None,
                 path: Optional[str] = None,
                 timeout_in_seconds: Optional[float] = None,
                 tolerated_number_of_failures: Optional[float] = None):
        """
        :param float port: The port number used by the monitoring checks.
        :param str protocol: The protocol used by the monitoring checks, supported values are `HTTP`, `HTTPS` and `TCP`.
        :param List['TrafficManagerProfileMonitorConfigCustomHeaderArgs'] custom_headers: One or more `custom_header` blocks as defined below.
        :param List[str] expected_status_code_ranges: A list of status code ranges in the format of `100-101`.
        :param float interval_in_seconds: The interval used to check the endpoint health from a Traffic Manager probing agent. You can specify two values here: `30` (normal probing) and `10` (fast probing). The default value is `30`.
        :param str path: The path used by the monitoring checks. Required when `protocol` is set to `HTTP` or `HTTPS` - cannot be set when `protocol` is set to `TCP`.
        :param float timeout_in_seconds: The amount of time the Traffic Manager probing agent should wait before considering that check a failure when a health check probe is sent to the endpoint. If `interval_in_seconds` is set to `30`, then `timeout_in_seconds` can be between `5` and `10`. The default value is `10`. If `interval_in_seconds` is set to `10`, then valid values are between `5` and `9` and `timeout_in_seconds` is required.
        :param float tolerated_number_of_failures: The number of failures a Traffic Manager probing agent tolerates before marking that endpoint as unhealthy. Valid values are between `0` and `9`. The default value is `3`
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)
        if custom_headers is not None:
            pulumi.set(__self__, "custom_headers", custom_headers)
        if expected_status_code_ranges is not None:
            pulumi.set(__self__, "expected_status_code_ranges", expected_status_code_ranges)
        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 timeout_in_seconds is not None:
            pulumi.set(__self__, "timeout_in_seconds", timeout_in_seconds)
        if tolerated_number_of_failures is not None:
            pulumi.set(__self__, "tolerated_number_of_failures", tolerated_number_of_failures)

    @property
    @pulumi.getter
    def port(self) -> float:
        """
        The port number used by the monitoring checks.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The protocol used by the monitoring checks, supported values are `HTTP`, `HTTPS` and `TCP`.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="customHeaders")
    def custom_headers(self) -> Optional[List['outputs.TrafficManagerProfileMonitorConfigCustomHeader']]:
        """
        One or more `custom_header` blocks as defined below.
        """
        return pulumi.get(self, "custom_headers")

    @property
    @pulumi.getter(name="expectedStatusCodeRanges")
    def expected_status_code_ranges(self) -> Optional[List[str]]:
        """
        A list of status code ranges in the format of `100-101`.
        """
        return pulumi.get(self, "expected_status_code_ranges")

    @property
    @pulumi.getter(name="intervalInSeconds")
    def interval_in_seconds(self) -> Optional[float]:
        """
        The interval used to check the endpoint health from a Traffic Manager probing agent. You can specify two values here: `30` (normal probing) and `10` (fast probing). The default value is `30`.
        """
        return pulumi.get(self, "interval_in_seconds")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The path used by the monitoring checks. Required when `protocol` is set to `HTTP` or `HTTPS` - cannot be set when `protocol` is set to `TCP`.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter(name="timeoutInSeconds")
    def timeout_in_seconds(self) -> Optional[float]:
        """
        The amount of time the Traffic Manager probing agent should wait before considering that check a failure when a health check probe is sent to the endpoint. If `interval_in_seconds` is set to `30`, then `timeout_in_seconds` can be between `5` and `10`. The default value is `10`. If `interval_in_seconds` is set to `10`, then valid values are between `5` and `9` and `timeout_in_seconds` is required.
        """
        return pulumi.get(self, "timeout_in_seconds")

    @property
    @pulumi.getter(name="toleratedNumberOfFailures")
    def tolerated_number_of_failures(self) -> Optional[float]:
        """
        The number of failures a Traffic Manager probing agent tolerates before marking that endpoint as unhealthy. Valid values are between `0` and `9`. The default value is `3`
        """
        return pulumi.get(self, "tolerated_number_of_failures")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class TrafficManagerProfileMonitorConfigCustomHeader(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The name of the custom header.
        :param str value: The value of custom header. Applicable for Http and Https protocol.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the custom header.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The value of custom header. Applicable for Http and Https protocol.
        """
        return pulumi.get(self, "value")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VirtualHubRoute(dict):
    def __init__(__self__, *,
                 address_prefixes: List[str],
                 next_hop_ip_address: str):
        """
        :param List[str] address_prefixes: A list of Address Prefixes.
        :param str next_hop_ip_address: The IP Address that Packets should be forwarded to as the Next Hop.
        """
        pulumi.set(__self__, "address_prefixes", address_prefixes)
        pulumi.set(__self__, "next_hop_ip_address", next_hop_ip_address)

    @property
    @pulumi.getter(name="addressPrefixes")
    def address_prefixes(self) -> List[str]:
        """
        A list of Address Prefixes.
        """
        return pulumi.get(self, "address_prefixes")

    @property
    @pulumi.getter(name="nextHopIpAddress")
    def next_hop_ip_address(self) -> str:
        """
        The IP Address that Packets should be forwarded to as the Next Hop.
        """
        return pulumi.get(self, "next_hop_ip_address")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VirtualNetworkDdosProtectionPlan(dict):
    def __init__(__self__, *,
                 enable: bool,
                 id: str):
        """
        :param bool enable: Enable/disable DDoS Protection Plan on Virtual Network.
        :param str id: The ID of DDoS Protection Plan.
        """
        pulumi.set(__self__, "enable", enable)
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def enable(self) -> bool:
        """
        Enable/disable DDoS Protection Plan on Virtual Network.
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of DDoS Protection Plan.
        """
        return pulumi.get(self, "id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VirtualNetworkGatewayBgpSettings(dict):
    def __init__(__self__, *,
                 asn: Optional[float] = None,
                 peer_weight: Optional[float] = None,
                 peering_address: Optional[str] = None):
        """
        :param float asn: The Autonomous System Number (ASN) to use as part of the BGP.
        :param float peer_weight: The weight added to routes which have been learned
               through BGP peering. Valid values can be between `0` and `100`.
        :param str peering_address: The BGP peer IP address of the virtual network
               gateway. This address is needed to configure the created gateway as a BGP Peer
               on the on-premises VPN devices. The IP address must be part of the subnet of
               the Virtual Network Gateway. Changing this forces a new resource to be created.
        """
        if asn is not None:
            pulumi.set(__self__, "asn", asn)
        if peer_weight is not None:
            pulumi.set(__self__, "peer_weight", peer_weight)
        if peering_address is not None:
            pulumi.set(__self__, "peering_address", peering_address)

    @property
    @pulumi.getter
    def asn(self) -> Optional[float]:
        """
        The Autonomous System Number (ASN) to use as part of the BGP.
        """
        return pulumi.get(self, "asn")

    @property
    @pulumi.getter(name="peerWeight")
    def peer_weight(self) -> Optional[float]:
        """
        The weight added to routes which have been learned
        through BGP peering. Valid values can be between `0` and `100`.
        """
        return pulumi.get(self, "peer_weight")

    @property
    @pulumi.getter(name="peeringAddress")
    def peering_address(self) -> Optional[str]:
        """
        The BGP peer IP address of the virtual network
        gateway. This address is needed to configure the created gateway as a BGP Peer
        on the on-premises VPN devices. The IP address must be part of the subnet of
        the Virtual Network Gateway. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "peering_address")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VirtualNetworkGatewayConnectionIpsecPolicy(dict):
    def __init__(__self__, *,
                 dh_group: str,
                 ike_encryption: str,
                 ike_integrity: str,
                 ipsec_encryption: str,
                 ipsec_integrity: str,
                 pfs_group: str,
                 sa_datasize: Optional[float] = None,
                 sa_lifetime: Optional[float] = None):
        """
        :param str dh_group: The DH group used in IKE phase 1 for initial SA. Valid
               options are `DHGroup1`, `DHGroup14`, `DHGroup2`, `DHGroup2048`, `DHGroup24`,
               `ECP256`, `ECP384`, or `None`.
        :param str ike_encryption: The IKE encryption algorithm. Valid
               options are `AES128`, `AES192`, `AES256`, `DES`, or `DES3`.
        :param str ike_integrity: The IKE integrity algorithm. Valid
               options are `MD5`, `SHA1`, `SHA256`, or `SHA384`.
        :param str ipsec_encryption: The IPSec encryption algorithm. Valid
               options are `AES128`, `AES192`, `AES256`, `DES`, `DES3`, `GCMAES128`, `GCMAES192`, `GCMAES256`, or `None`.
        :param str ipsec_integrity: The IPSec integrity algorithm. Valid
               options are `GCMAES128`, `GCMAES192`, `GCMAES256`, `MD5`, `SHA1`, or `SHA256`.
        :param str pfs_group: The DH group used in IKE phase 2 for new child SA.
               Valid options are `ECP256`, `ECP384`, `PFS1`, `PFS2`, `PFS2048`, `PFS24`,
               or `None`.
        :param float sa_datasize: The IPSec SA payload size in KB. Must be at least
               `1024` KB. Defaults to `102400000` KB.
        :param float sa_lifetime: The IPSec SA lifetime in seconds. Must be at least
               `300` seconds. Defaults to `27000` seconds.
        """
        pulumi.set(__self__, "dh_group", dh_group)
        pulumi.set(__self__, "ike_encryption", ike_encryption)
        pulumi.set(__self__, "ike_integrity", ike_integrity)
        pulumi.set(__self__, "ipsec_encryption", ipsec_encryption)
        pulumi.set(__self__, "ipsec_integrity", ipsec_integrity)
        pulumi.set(__self__, "pfs_group", pfs_group)
        if sa_datasize is not None:
            pulumi.set(__self__, "sa_datasize", sa_datasize)
        if sa_lifetime is not None:
            pulumi.set(__self__, "sa_lifetime", sa_lifetime)

    @property
    @pulumi.getter(name="dhGroup")
    def dh_group(self) -> str:
        """
        The DH group used in IKE phase 1 for initial SA. Valid
        options are `DHGroup1`, `DHGroup14`, `DHGroup2`, `DHGroup2048`, `DHGroup24`,
        `ECP256`, `ECP384`, or `None`.
        """
        return pulumi.get(self, "dh_group")

    @property
    @pulumi.getter(name="ikeEncryption")
    def ike_encryption(self) -> str:
        """
        The IKE encryption algorithm. Valid
        options are `AES128`, `AES192`, `AES256`, `DES`, or `DES3`.
        """
        return pulumi.get(self, "ike_encryption")

    @property
    @pulumi.getter(name="ikeIntegrity")
    def ike_integrity(self) -> str:
        """
        The IKE integrity algorithm. Valid
        options are `MD5`, `SHA1`, `SHA256`, or `SHA384`.
        """
        return pulumi.get(self, "ike_integrity")

    @property
    @pulumi.getter(name="ipsecEncryption")
    def ipsec_encryption(self) -> str:
        """
        The IPSec encryption algorithm. Valid
        options are `AES128`, `AES192`, `AES256`, `DES`, `DES3`, `GCMAES128`, `GCMAES192`, `GCMAES256`, or `None`.
        """
        return pulumi.get(self, "ipsec_encryption")

    @property
    @pulumi.getter(name="ipsecIntegrity")
    def ipsec_integrity(self) -> str:
        """
        The IPSec integrity algorithm. Valid
        options are `GCMAES128`, `GCMAES192`, `GCMAES256`, `MD5`, `SHA1`, or `SHA256`.
        """
        return pulumi.get(self, "ipsec_integrity")

    @property
    @pulumi.getter(name="pfsGroup")
    def pfs_group(self) -> str:
        """
        The DH group used in IKE phase 2 for new child SA.
        Valid options are `ECP256`, `ECP384`, `PFS1`, `PFS2`, `PFS2048`, `PFS24`,
        or `None`.
        """
        return pulumi.get(self, "pfs_group")

    @property
    @pulumi.getter(name="saDatasize")
    def sa_datasize(self) -> Optional[float]:
        """
        The IPSec SA payload size in KB. Must be at least
        `1024` KB. Defaults to `102400000` KB.
        """
        return pulumi.get(self, "sa_datasize")

    @property
    @pulumi.getter(name="saLifetime")
    def sa_lifetime(self) -> Optional[float]:
        """
        The IPSec SA lifetime in seconds. Must be at least
        `300` seconds. Defaults to `27000` seconds.
        """
        return pulumi.get(self, "sa_lifetime")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VirtualNetworkGatewayConnectionTrafficSelectorPolicy(dict):
    def __init__(__self__, *,
                 local_address_cidrs: List[str],
                 remote_address_cidrs: List[str]):
        pulumi.set(__self__, "local_address_cidrs", local_address_cidrs)
        pulumi.set(__self__, "remote_address_cidrs", remote_address_cidrs)

    @property
    @pulumi.getter(name="localAddressCidrs")
    def local_address_cidrs(self) -> List[str]:
        return pulumi.get(self, "local_address_cidrs")

    @property
    @pulumi.getter(name="remoteAddressCidrs")
    def remote_address_cidrs(self) -> List[str]:
        return pulumi.get(self, "remote_address_cidrs")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VirtualNetworkGatewayIpConfiguration(dict):
    def __init__(__self__, *,
                 public_ip_address_id: str,
                 subnet_id: str,
                 name: Optional[str] = None,
                 private_ip_address_allocation: Optional[str] = None):
        """
        :param str public_ip_address_id: The ID of the public ip address to associate
               with the Virtual Network Gateway.
        :param str subnet_id: The ID of the gateway subnet of a virtual network in
               which the virtual network gateway will be created. It is mandatory that
               the associated subnet is named `GatewaySubnet`. Therefore, each virtual
               network can contain at most a single Virtual Network Gateway.
        :param str name: A user-defined name of the revoked certificate.
        :param str private_ip_address_allocation: Defines how the private IP address
               of the gateways virtual interface is assigned. Valid options are `Static` or
               `Dynamic`. Defaults to `Dynamic`.
        """
        pulumi.set(__self__, "public_ip_address_id", public_ip_address_id)
        pulumi.set(__self__, "subnet_id", subnet_id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if private_ip_address_allocation is not None:
            pulumi.set(__self__, "private_ip_address_allocation", private_ip_address_allocation)

    @property
    @pulumi.getter(name="publicIpAddressId")
    def public_ip_address_id(self) -> str:
        """
        The ID of the public ip address to associate
        with the Virtual Network Gateway.
        """
        return pulumi.get(self, "public_ip_address_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        The ID of the gateway subnet of a virtual network in
        which the virtual network gateway will be created. It is mandatory that
        the associated subnet is named `GatewaySubnet`. Therefore, each virtual
        network can contain at most a single Virtual Network Gateway.
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        A user-defined name of the revoked certificate.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="privateIpAddressAllocation")
    def private_ip_address_allocation(self) -> Optional[str]:
        """
        Defines how the private IP address
        of the gateways virtual interface is assigned. Valid options are `Static` or
        `Dynamic`. Defaults to `Dynamic`.
        """
        return pulumi.get(self, "private_ip_address_allocation")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VirtualNetworkGatewayVpnClientConfiguration(dict):
    def __init__(__self__, *,
                 address_spaces: List[str],
                 aad_audience: Optional[str] = None,
                 aad_issuer: Optional[str] = None,
                 aad_tenant: Optional[str] = None,
                 radius_server_address: Optional[str] = None,
                 radius_server_secret: Optional[str] = None,
                 revoked_certificates: Optional[List['outputs.VirtualNetworkGatewayVpnClientConfigurationRevokedCertificate']] = None,
                 root_certificates: Optional[List['outputs.VirtualNetworkGatewayVpnClientConfigurationRootCertificate']] = None,
                 vpn_client_protocols: Optional[List[str]] = None):
        """
        :param List[str] address_spaces: The address space out of which ip addresses for
               vpn clients will be taken. You can provide more than one address space, e.g.
               in CIDR notation.
        :param str aad_audience: The client id of the Azure VPN application.
               See [Create an Active Directory (AD) tenant for P2S OpenVPN protocol connections](https://docs.microsoft.com/en-gb/azure/vpn-gateway/openvpn-azure-ad-tenant-multi-app) for values
               This setting is incompatible with the use of
               `root_certificate` and `revoked_certificate`, `radius_server_address`, and `radius_server_secret`.
        :param str aad_issuer: The STS url for your tenant
               This setting is incompatible with the use of
               `root_certificate` and `revoked_certificate`, `radius_server_address`, and `radius_server_secret`.
        :param str aad_tenant: AzureAD Tenant URL
               This setting is incompatible with the use of
               `root_certificate` and `revoked_certificate`, `radius_server_address`, and `radius_server_secret`.
        :param str radius_server_address: The address of the Radius server.
               This setting is incompatible with the use of
               `aad_tenant`, `aad_audience`, `aad_issuer`, `root_certificate` and `revoked_certificate`.
        :param str radius_server_secret: The secret used by the Radius server.
               This setting is incompatible with the use of
               `aad_tenant`, `aad_audience`, `aad_issuer`, `root_certificate` and `revoked_certificate`.
        :param List['VirtualNetworkGatewayVpnClientConfigurationRevokedCertificateArgs'] revoked_certificates: One or more `revoked_certificate` blocks which
               are defined below.
               This setting is incompatible with the use of
               `aad_tenant`, `aad_audience`, `aad_issuer`, `radius_server_address`, and `radius_server_secret`.
        :param List['VirtualNetworkGatewayVpnClientConfigurationRootCertificateArgs'] root_certificates: One or more `root_certificate` blocks which are
               defined below. These root certificates are used to sign the client certificate
               used by the VPN clients to connect to the gateway.
               This setting is incompatible with the use of
               `aad_tenant`, `aad_audience`, `aad_issuer`, `radius_server_address`, and `radius_server_secret`.
        :param List[str] vpn_client_protocols: List of the protocols supported by the vpn client.
               The supported values are `SSTP`, `IkeV2` and `OpenVPN`.
               Values `SSTP` and `IkeV2` are incompatible with the use of
               `aad_tenant`, `aad_audience` and `aad_issuer`.
        """
        pulumi.set(__self__, "address_spaces", address_spaces)
        if aad_audience is not None:
            pulumi.set(__self__, "aad_audience", aad_audience)
        if aad_issuer is not None:
            pulumi.set(__self__, "aad_issuer", aad_issuer)
        if aad_tenant is not None:
            pulumi.set(__self__, "aad_tenant", aad_tenant)
        if radius_server_address is not None:
            pulumi.set(__self__, "radius_server_address", radius_server_address)
        if radius_server_secret is not None:
            pulumi.set(__self__, "radius_server_secret", radius_server_secret)
        if revoked_certificates is not None:
            pulumi.set(__self__, "revoked_certificates", revoked_certificates)
        if root_certificates is not None:
            pulumi.set(__self__, "root_certificates", root_certificates)
        if vpn_client_protocols is not None:
            pulumi.set(__self__, "vpn_client_protocols", vpn_client_protocols)

    @property
    @pulumi.getter(name="addressSpaces")
    def address_spaces(self) -> List[str]:
        """
        The address space out of which ip addresses for
        vpn clients will be taken. You can provide more than one address space, e.g.
        in CIDR notation.
        """
        return pulumi.get(self, "address_spaces")

    @property
    @pulumi.getter(name="aadAudience")
    def aad_audience(self) -> Optional[str]:
        """
        The client id of the Azure VPN application.
        See [Create an Active Directory (AD) tenant for P2S OpenVPN protocol connections](https://docs.microsoft.com/en-gb/azure/vpn-gateway/openvpn-azure-ad-tenant-multi-app) for values
        This setting is incompatible with the use of
        `root_certificate` and `revoked_certificate`, `radius_server_address`, and `radius_server_secret`.
        """
        return pulumi.get(self, "aad_audience")

    @property
    @pulumi.getter(name="aadIssuer")
    def aad_issuer(self) -> Optional[str]:
        """
        The STS url for your tenant
        This setting is incompatible with the use of
        `root_certificate` and `revoked_certificate`, `radius_server_address`, and `radius_server_secret`.
        """
        return pulumi.get(self, "aad_issuer")

    @property
    @pulumi.getter(name="aadTenant")
    def aad_tenant(self) -> Optional[str]:
        """
        AzureAD Tenant URL
        This setting is incompatible with the use of
        `root_certificate` and `revoked_certificate`, `radius_server_address`, and `radius_server_secret`.
        """
        return pulumi.get(self, "aad_tenant")

    @property
    @pulumi.getter(name="radiusServerAddress")
    def radius_server_address(self) -> Optional[str]:
        """
        The address of the Radius server.
        This setting is incompatible with the use of
        `aad_tenant`, `aad_audience`, `aad_issuer`, `root_certificate` and `revoked_certificate`.
        """
        return pulumi.get(self, "radius_server_address")

    @property
    @pulumi.getter(name="radiusServerSecret")
    def radius_server_secret(self) -> Optional[str]:
        """
        The secret used by the Radius server.
        This setting is incompatible with the use of
        `aad_tenant`, `aad_audience`, `aad_issuer`, `root_certificate` and `revoked_certificate`.
        """
        return pulumi.get(self, "radius_server_secret")

    @property
    @pulumi.getter(name="revokedCertificates")
    def revoked_certificates(self) -> Optional[List['outputs.VirtualNetworkGatewayVpnClientConfigurationRevokedCertificate']]:
        """
        One or more `revoked_certificate` blocks which
        are defined below.
        This setting is incompatible with the use of
        `aad_tenant`, `aad_audience`, `aad_issuer`, `radius_server_address`, and `radius_server_secret`.
        """
        return pulumi.get(self, "revoked_certificates")

    @property
    @pulumi.getter(name="rootCertificates")
    def root_certificates(self) -> Optional[List['outputs.VirtualNetworkGatewayVpnClientConfigurationRootCertificate']]:
        """
        One or more `root_certificate` blocks which are
        defined below. These root certificates are used to sign the client certificate
        used by the VPN clients to connect to the gateway.
        This setting is incompatible with the use of
        `aad_tenant`, `aad_audience`, `aad_issuer`, `radius_server_address`, and `radius_server_secret`.
        """
        return pulumi.get(self, "root_certificates")

    @property
    @pulumi.getter(name="vpnClientProtocols")
    def vpn_client_protocols(self) -> Optional[List[str]]:
        """
        List of the protocols supported by the vpn client.
        The supported values are `SSTP`, `IkeV2` and `OpenVPN`.
        Values `SSTP` and `IkeV2` are incompatible with the use of
        `aad_tenant`, `aad_audience` and `aad_issuer`.
        """
        return pulumi.get(self, "vpn_client_protocols")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VirtualNetworkGatewayVpnClientConfigurationRevokedCertificate(dict):
    def __init__(__self__, *,
                 name: str,
                 thumbprint: str):
        """
        :param str name: A user-defined name of the revoked certificate.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A user-defined name of the revoked certificate.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def thumbprint(self) -> str:
        return pulumi.get(self, "thumbprint")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VirtualNetworkGatewayVpnClientConfigurationRootCertificate(dict):
    def __init__(__self__, *,
                 name: str,
                 public_cert_data: str):
        """
        :param str name: A user-defined name of the revoked certificate.
        :param str public_cert_data: The SHA1 thumbprint of the certificate to be
               revoked.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "public_cert_data", public_cert_data)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A user-defined name of the revoked certificate.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="publicCertData")
    def public_cert_data(self) -> str:
        """
        The SHA1 thumbprint of the certificate to be
        revoked.
        """
        return pulumi.get(self, "public_cert_data")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VirtualNetworkSubnet(dict):
    def __init__(__self__, *,
                 address_prefix: str,
                 name: str,
                 id: Optional[str] = None,
                 security_group: Optional[str] = None):
        """
        :param str address_prefix: The address prefix to use for the subnet.
        :param str name: The name of the virtual network. Changing this forces a new resource to be created.
        :param str id: The ID of DDoS Protection Plan.
        :param str security_group: The Network Security Group to associate with the subnet. (Referenced by `id`, ie. `azurerm_network_security_group.example.id`)
        """
        pulumi.set(__self__, "address_prefix", address_prefix)
        pulumi.set(__self__, "name", name)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if security_group is not None:
            pulumi.set(__self__, "security_group", security_group)

    @property
    @pulumi.getter(name="addressPrefix")
    def address_prefix(self) -> str:
        """
        The address prefix to use for the subnet.
        """
        return pulumi.get(self, "address_prefix")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the virtual network. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="securityGroup")
    def security_group(self) -> Optional[str]:
        """
        The Network Security Group to associate with the subnet. (Referenced by `id`, ie. `azurerm_network_security_group.example.id`)
        """
        return pulumi.get(self, "security_group")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VpnGatewayBgpSetting(dict):
    def __init__(__self__, *,
                 asn: float,
                 peer_weight: float,
                 bgp_peering_address: Optional[str] = None):
        """
        :param float asn: The ASN of the BGP Speaker. Changing this forces a new resource to be created.
        :param float peer_weight: The weight added to Routes learned from this BGP Speaker. Changing this forces a new resource to be created.
        :param str bgp_peering_address: The Address which should be used for the BGP Peering.
        """
        pulumi.set(__self__, "asn", asn)
        pulumi.set(__self__, "peer_weight", peer_weight)
        if bgp_peering_address is not None:
            pulumi.set(__self__, "bgp_peering_address", bgp_peering_address)

    @property
    @pulumi.getter
    def asn(self) -> float:
        """
        The ASN of the BGP Speaker. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "asn")

    @property
    @pulumi.getter(name="peerWeight")
    def peer_weight(self) -> float:
        """
        The weight added to Routes learned from this BGP Speaker. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "peer_weight")

    @property
    @pulumi.getter(name="bgpPeeringAddress")
    def bgp_peering_address(self) -> Optional[str]:
        """
        The Address which should be used for the BGP Peering.
        """
        return pulumi.get(self, "bgp_peering_address")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VpnServerConfigurationAzureActiveDirectoryAuthentication(dict):
    def __init__(__self__, *,
                 audience: str,
                 issuer: str,
                 tenant: str):
        """
        :param str audience: The Audience which should be used for authentication.
        :param str issuer: The Issuer which should be used for authentication.
        :param str tenant: The Tenant which should be used for authentication.
        """
        pulumi.set(__self__, "audience", audience)
        pulumi.set(__self__, "issuer", issuer)
        pulumi.set(__self__, "tenant", tenant)

    @property
    @pulumi.getter
    def audience(self) -> str:
        """
        The Audience which should be used for authentication.
        """
        return pulumi.get(self, "audience")

    @property
    @pulumi.getter
    def issuer(self) -> str:
        """
        The Issuer which should be used for authentication.
        """
        return pulumi.get(self, "issuer")

    @property
    @pulumi.getter
    def tenant(self) -> str:
        """
        The Tenant which should be used for authentication.
        """
        return pulumi.get(self, "tenant")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VpnServerConfigurationClientRevokedCertificate(dict):
    def __init__(__self__, *,
                 name: str,
                 thumbprint: str):
        """
        :param str name: A name used to uniquely identify this certificate.
        :param str thumbprint: The Thumbprint of the Certificate.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A name used to uniquely identify this certificate.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def thumbprint(self) -> str:
        """
        The Thumbprint of the Certificate.
        """
        return pulumi.get(self, "thumbprint")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VpnServerConfigurationClientRootCertificate(dict):
    def __init__(__self__, *,
                 name: str,
                 public_cert_data: str):
        """
        :param str name: A name used to uniquely identify this certificate.
        :param str public_cert_data: The Public Key Data associated with the Certificate.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "public_cert_data", public_cert_data)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A name used to uniquely identify this certificate.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="publicCertData")
    def public_cert_data(self) -> str:
        """
        The Public Key Data associated with the Certificate.
        """
        return pulumi.get(self, "public_cert_data")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VpnServerConfigurationIpsecPolicy(dict):
    def __init__(__self__, *,
                 dh_group: str,
                 ike_encryption: str,
                 ike_integrity: str,
                 ipsec_encryption: str,
                 ipsec_integrity: str,
                 pfs_group: str,
                 sa_data_size_kilobytes: float,
                 sa_lifetime_seconds: float):
        """
        :param str dh_group: The DH Group, used in IKE Phase 1. Possible values include `DHGroup1`, `DHGroup2`, `DHGroup14`, `DHGroup24`, `DHGroup2048`, `ECP256`, `ECP384` and `None`.
        :param str ike_encryption: The IKE encryption algorithm, used for IKE Phase 2. Possible values include `AES128`, `AES192`, `AES256`, `DES`, `DES3`, `GCMAES128` and `GCMAES256`.
        :param str ike_integrity: The IKE encryption integrity algorithm, used for IKE Phase 2. Possible values include `GCMAES128`, `GCMAES256`, `MD5`, `SHA1`, `SHA256` and `SHA384`.
        :param str ipsec_encryption: The IPSec encryption algorithm, used for IKE phase 1. Possible values include `AES128`, `AES192`, `AES256`, `DES`, `DES3`, `GCMAES128`, `GCMAES192`, `GCMAES256` and `None`.
        :param str ipsec_integrity: The IPSec integrity algorithm, used for IKE phase 1. Possible values include `GCMAES128`, `GCMAES192`, `GCMAES256`, `MD5`, `SHA1` and `SHA256`.
        :param str pfs_group: The Pfs Group, used in IKE Phase 2. Possible values include `ECP256`, `ECP384`, `PFS1`, `PFS2`, `PFS14`, `PFS24`, `PFS2048`, `PFSMM` and `None`.
        :param float sa_data_size_kilobytes: The IPSec Security Association payload size in KB for a Site-to-Site VPN tunnel.
        :param float sa_lifetime_seconds: The IPSec Security Association lifetime in seconds for a Site-to-Site VPN tunnel.
        """
        pulumi.set(__self__, "dh_group", dh_group)
        pulumi.set(__self__, "ike_encryption", ike_encryption)
        pulumi.set(__self__, "ike_integrity", ike_integrity)
        pulumi.set(__self__, "ipsec_encryption", ipsec_encryption)
        pulumi.set(__self__, "ipsec_integrity", ipsec_integrity)
        pulumi.set(__self__, "pfs_group", pfs_group)
        pulumi.set(__self__, "sa_data_size_kilobytes", sa_data_size_kilobytes)
        pulumi.set(__self__, "sa_lifetime_seconds", sa_lifetime_seconds)

    @property
    @pulumi.getter(name="dhGroup")
    def dh_group(self) -> str:
        """
        The DH Group, used in IKE Phase 1. Possible values include `DHGroup1`, `DHGroup2`, `DHGroup14`, `DHGroup24`, `DHGroup2048`, `ECP256`, `ECP384` and `None`.
        """
        return pulumi.get(self, "dh_group")

    @property
    @pulumi.getter(name="ikeEncryption")
    def ike_encryption(self) -> str:
        """
        The IKE encryption algorithm, used for IKE Phase 2. Possible values include `AES128`, `AES192`, `AES256`, `DES`, `DES3`, `GCMAES128` and `GCMAES256`.
        """
        return pulumi.get(self, "ike_encryption")

    @property
    @pulumi.getter(name="ikeIntegrity")
    def ike_integrity(self) -> str:
        """
        The IKE encryption integrity algorithm, used for IKE Phase 2. Possible values include `GCMAES128`, `GCMAES256`, `MD5`, `SHA1`, `SHA256` and `SHA384`.
        """
        return pulumi.get(self, "ike_integrity")

    @property
    @pulumi.getter(name="ipsecEncryption")
    def ipsec_encryption(self) -> str:
        """
        The IPSec encryption algorithm, used for IKE phase 1. Possible values include `AES128`, `AES192`, `AES256`, `DES`, `DES3`, `GCMAES128`, `GCMAES192`, `GCMAES256` and `None`.
        """
        return pulumi.get(self, "ipsec_encryption")

    @property
    @pulumi.getter(name="ipsecIntegrity")
    def ipsec_integrity(self) -> str:
        """
        The IPSec integrity algorithm, used for IKE phase 1. Possible values include `GCMAES128`, `GCMAES192`, `GCMAES256`, `MD5`, `SHA1` and `SHA256`.
        """
        return pulumi.get(self, "ipsec_integrity")

    @property
    @pulumi.getter(name="pfsGroup")
    def pfs_group(self) -> str:
        """
        The Pfs Group, used in IKE Phase 2. Possible values include `ECP256`, `ECP384`, `PFS1`, `PFS2`, `PFS14`, `PFS24`, `PFS2048`, `PFSMM` and `None`.
        """
        return pulumi.get(self, "pfs_group")

    @property
    @pulumi.getter(name="saDataSizeKilobytes")
    def sa_data_size_kilobytes(self) -> float:
        """
        The IPSec Security Association payload size in KB for a Site-to-Site VPN tunnel.
        """
        return pulumi.get(self, "sa_data_size_kilobytes")

    @property
    @pulumi.getter(name="saLifetimeSeconds")
    def sa_lifetime_seconds(self) -> float:
        """
        The IPSec Security Association lifetime in seconds for a Site-to-Site VPN tunnel.
        """
        return pulumi.get(self, "sa_lifetime_seconds")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VpnServerConfigurationRadiusServer(dict):
    def __init__(__self__, *,
                 address: str,
                 secret: str,
                 server_root_certificates: List['outputs.VpnServerConfigurationRadiusServerServerRootCertificate'],
                 client_root_certificates: Optional[List['outputs.VpnServerConfigurationRadiusServerClientRootCertificate']] = None):
        """
        :param str address: The Address of the Radius Server.
        :param str secret: The Secret used to communicate with the Radius Server.
        :param List['VpnServerConfigurationRadiusServerServerRootCertificateArgs'] server_root_certificates: One or more `server_root_certificate` blocks as defined below.
        :param List['VpnServerConfigurationRadiusServerClientRootCertificateArgs'] client_root_certificates: One or more `client_root_certificate` blocks as defined above.
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "secret", secret)
        pulumi.set(__self__, "server_root_certificates", server_root_certificates)
        if client_root_certificates is not None:
            pulumi.set(__self__, "client_root_certificates", client_root_certificates)

    @property
    @pulumi.getter
    def address(self) -> str:
        """
        The Address of the Radius Server.
        """
        return pulumi.get(self, "address")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Secret used to communicate with the Radius Server.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter(name="serverRootCertificates")
    def server_root_certificates(self) -> List['outputs.VpnServerConfigurationRadiusServerServerRootCertificate']:
        """
        One or more `server_root_certificate` blocks as defined below.
        """
        return pulumi.get(self, "server_root_certificates")

    @property
    @pulumi.getter(name="clientRootCertificates")
    def client_root_certificates(self) -> Optional[List['outputs.VpnServerConfigurationRadiusServerClientRootCertificate']]:
        """
        One or more `client_root_certificate` blocks as defined above.
        """
        return pulumi.get(self, "client_root_certificates")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VpnServerConfigurationRadiusServerClientRootCertificate(dict):
    def __init__(__self__, *,
                 name: str,
                 thumbprint: str):
        """
        :param str name: A name used to uniquely identify this certificate.
        :param str thumbprint: The Thumbprint of the Certificate.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A name used to uniquely identify this certificate.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def thumbprint(self) -> str:
        """
        The Thumbprint of the Certificate.
        """
        return pulumi.get(self, "thumbprint")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class VpnServerConfigurationRadiusServerServerRootCertificate(dict):
    def __init__(__self__, *,
                 name: str,
                 public_cert_data: str):
        """
        :param str name: A name used to uniquely identify this certificate.
        :param str public_cert_data: The Public Key Data associated with the Certificate.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "public_cert_data", public_cert_data)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A name used to uniquely identify this certificate.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="publicCertData")
    def public_cert_data(self) -> str:
        """
        The Public Key Data associated with the Certificate.
        """
        return pulumi.get(self, "public_cert_data")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class GetExpressRouteCircuitPeeringResult(dict):
    def __init__(__self__, *,
                 azure_asn: float,
                 peer_asn: float,
                 peering_type: str,
                 primary_peer_address_prefix: str,
                 secondary_peer_address_prefix: str,
                 shared_key: str,
                 vlan_id: float):
        """
        :param float azure_asn: The Either a 16-bit or a 32-bit ASN for Azure.
        :param float peer_asn: The Either a 16-bit or a 32-bit ASN. Can either be public or private.
        :param str peering_type: The type of the ExpressRoute Circuit Peering. Acceptable values include `AzurePrivatePeering`, `AzurePublicPeering` and `MicrosoftPeering`. Changing this forces a new resource to be created.
        :param str primary_peer_address_prefix: A `/30` subnet for the primary link.
        :param str secondary_peer_address_prefix: A `/30` subnet for the secondary link.
        :param str shared_key: The shared key. Can be a maximum of 25 characters.
        :param float vlan_id: A valid VLAN ID to establish this peering on.
        """
        pulumi.set(__self__, "azure_asn", azure_asn)
        pulumi.set(__self__, "peer_asn", peer_asn)
        pulumi.set(__self__, "peering_type", peering_type)
        pulumi.set(__self__, "primary_peer_address_prefix", primary_peer_address_prefix)
        pulumi.set(__self__, "secondary_peer_address_prefix", secondary_peer_address_prefix)
        pulumi.set(__self__, "shared_key", shared_key)
        pulumi.set(__self__, "vlan_id", vlan_id)

    @property
    @pulumi.getter(name="azureAsn")
    def azure_asn(self) -> float:
        """
        The Either a 16-bit or a 32-bit ASN for Azure.
        """
        return pulumi.get(self, "azure_asn")

    @property
    @pulumi.getter(name="peerAsn")
    def peer_asn(self) -> float:
        """
        The Either a 16-bit or a 32-bit ASN. Can either be public or private.
        """
        return pulumi.get(self, "peer_asn")

    @property
    @pulumi.getter(name="peeringType")
    def peering_type(self) -> str:
        """
        The type of the ExpressRoute Circuit Peering. Acceptable values include `AzurePrivatePeering`, `AzurePublicPeering` and `MicrosoftPeering`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "peering_type")

    @property
    @pulumi.getter(name="primaryPeerAddressPrefix")
    def primary_peer_address_prefix(self) -> str:
        """
        A `/30` subnet for the primary link.
        """
        return pulumi.get(self, "primary_peer_address_prefix")

    @property
    @pulumi.getter(name="secondaryPeerAddressPrefix")
    def secondary_peer_address_prefix(self) -> str:
        """
        A `/30` subnet for the secondary link.
        """
        return pulumi.get(self, "secondary_peer_address_prefix")

    @property
    @pulumi.getter(name="sharedKey")
    def shared_key(self) -> str:
        """
        The shared key. Can be a maximum of 25 characters.
        """
        return pulumi.get(self, "shared_key")

    @property
    @pulumi.getter(name="vlanId")
    def vlan_id(self) -> float:
        """
        A valid VLAN ID to establish this peering on.
        """
        return pulumi.get(self, "vlan_id")


@pulumi.output_type
class GetExpressRouteCircuitServiceProviderPropertyResult(dict):
    def __init__(__self__, *,
                 bandwidth_in_mbps: float,
                 peering_location: str,
                 service_provider_name: str):
        """
        :param float bandwidth_in_mbps: The bandwidth in Mbps of the ExpressRoute circuit.
        :param str peering_location: The name of the peering location and **not** the Azure resource location.
        :param str service_provider_name: The name of the ExpressRoute Service Provider.
        """
        pulumi.set(__self__, "bandwidth_in_mbps", bandwidth_in_mbps)
        pulumi.set(__self__, "peering_location", peering_location)
        pulumi.set(__self__, "service_provider_name", service_provider_name)

    @property
    @pulumi.getter(name="bandwidthInMbps")
    def bandwidth_in_mbps(self) -> float:
        """
        The bandwidth in Mbps of the ExpressRoute circuit.
        """
        return pulumi.get(self, "bandwidth_in_mbps")

    @property
    @pulumi.getter(name="peeringLocation")
    def peering_location(self) -> str:
        """
        The name of the peering location and **not** the Azure resource location.
        """
        return pulumi.get(self, "peering_location")

    @property
    @pulumi.getter(name="serviceProviderName")
    def service_provider_name(self) -> str:
        """
        The name of the ExpressRoute Service Provider.
        """
        return pulumi.get(self, "service_provider_name")


@pulumi.output_type
class GetExpressRouteCircuitSkuResult(dict):
    def __init__(__self__, *,
                 family: str,
                 tier: str):
        """
        :param str family: The billing mode for bandwidth. Possible values are `MeteredData` or `UnlimitedData`.
        :param str tier: The service tier. Possible values are `Basic`, `Local`, `Standard` or `Premium`.
        """
        pulumi.set(__self__, "family", family)
        pulumi.set(__self__, "tier", tier)

    @property
    @pulumi.getter
    def family(self) -> str:
        """
        The billing mode for bandwidth. Possible values are `MeteredData` or `UnlimitedData`.
        """
        return pulumi.get(self, "family")

    @property
    @pulumi.getter
    def tier(self) -> str:
        """
        The service tier. Possible values are `Basic`, `Local`, `Standard` or `Premium`.
        """
        return pulumi.get(self, "tier")


@pulumi.output_type
class GetFirewallIpConfigurationResult(dict):
    def __init__(__self__, *,
                 internal_public_ip_address_id: str,
                 name: str,
                 private_ip_address: str,
                 public_ip_address_id: str,
                 subnet_id: str):
        """
        :param str name: The name of the Azure Firewall.
        :param str private_ip_address: The Private IP Address of the Azure Firewall.
        :param str subnet_id: The ID of the Subnet where the Azure Firewall is deployed.
        """
        pulumi.set(__self__, "internal_public_ip_address_id", internal_public_ip_address_id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "private_ip_address", private_ip_address)
        pulumi.set(__self__, "public_ip_address_id", public_ip_address_id)
        pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="internalPublicIpAddressId")
    def internal_public_ip_address_id(self) -> str:
        return pulumi.get(self, "internal_public_ip_address_id")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Azure Firewall.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> str:
        """
        The Private IP Address of the Azure Firewall.
        """
        return pulumi.get(self, "private_ip_address")

    @property
    @pulumi.getter(name="publicIpAddressId")
    def public_ip_address_id(self) -> str:
        return pulumi.get(self, "public_ip_address_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        The ID of the Subnet where the Azure Firewall is deployed.
        """
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class GetGatewayConnectionIpsecPolicyResult(dict):
    def __init__(__self__, *,
                 dh_group: str,
                 ike_encryption: str,
                 ike_integrity: str,
                 ipsec_encryption: str,
                 ipsec_integrity: str,
                 pfs_group: str,
                 sa_datasize: float,
                 sa_lifetime: float):
        """
        :param str dh_group: The DH group used in IKE phase 1 for initial SA. Valid
               options are `DHGroup1`, `DHGroup14`, `DHGroup2`, `DHGroup2048`, `DHGroup24`,
               `ECP256`, `ECP384`, or `None`.
        :param str ike_encryption: The IKE encryption algorithm. Valid
               options are `AES128`, `AES192`, `AES256`, `DES`, or `DES3`.
        :param str ike_integrity: The IKE integrity algorithm. Valid
               options are `MD5`, `SHA1`, `SHA256`, or `SHA384`.
        :param str ipsec_encryption: The IPSec encryption algorithm. Valid
               options are `AES128`, `AES192`, `AES256`, `DES`, `DES3`, `GCMAES128`, `GCMAES192`, `GCMAES256`, or `None`.
        :param str ipsec_integrity: The IPSec integrity algorithm. Valid
               options are `GCMAES128`, `GCMAES192`, `GCMAES256`, `MD5`, `SHA1`, or `SHA256`.
        :param str pfs_group: The DH group used in IKE phase 2 for new child SA.
               Valid options are `ECP256`, `ECP384`, `PFS1`, `PFS2`, `PFS2048`, `PFS24`,
               or `None`.
        :param float sa_datasize: The IPSec SA payload size in KB. Must be at least
               `1024` KB.
        :param float sa_lifetime: The IPSec SA lifetime in seconds. Must be at least
               `300` seconds.
        """
        pulumi.set(__self__, "dh_group", dh_group)
        pulumi.set(__self__, "ike_encryption", ike_encryption)
        pulumi.set(__self__, "ike_integrity", ike_integrity)
        pulumi.set(__self__, "ipsec_encryption", ipsec_encryption)
        pulumi.set(__self__, "ipsec_integrity", ipsec_integrity)
        pulumi.set(__self__, "pfs_group", pfs_group)
        pulumi.set(__self__, "sa_datasize", sa_datasize)
        pulumi.set(__self__, "sa_lifetime", sa_lifetime)

    @property
    @pulumi.getter(name="dhGroup")
    def dh_group(self) -> str:
        """
        The DH group used in IKE phase 1 for initial SA. Valid
        options are `DHGroup1`, `DHGroup14`, `DHGroup2`, `DHGroup2048`, `DHGroup24`,
        `ECP256`, `ECP384`, or `None`.
        """
        return pulumi.get(self, "dh_group")

    @property
    @pulumi.getter(name="ikeEncryption")
    def ike_encryption(self) -> str:
        """
        The IKE encryption algorithm. Valid
        options are `AES128`, `AES192`, `AES256`, `DES`, or `DES3`.
        """
        return pulumi.get(self, "ike_encryption")

    @property
    @pulumi.getter(name="ikeIntegrity")
    def ike_integrity(self) -> str:
        """
        The IKE integrity algorithm. Valid
        options are `MD5`, `SHA1`, `SHA256`, or `SHA384`.
        """
        return pulumi.get(self, "ike_integrity")

    @property
    @pulumi.getter(name="ipsecEncryption")
    def ipsec_encryption(self) -> str:
        """
        The IPSec encryption algorithm. Valid
        options are `AES128`, `AES192`, `AES256`, `DES`, `DES3`, `GCMAES128`, `GCMAES192`, `GCMAES256`, or `None`.
        """
        return pulumi.get(self, "ipsec_encryption")

    @property
    @pulumi.getter(name="ipsecIntegrity")
    def ipsec_integrity(self) -> str:
        """
        The IPSec integrity algorithm. Valid
        options are `GCMAES128`, `GCMAES192`, `GCMAES256`, `MD5`, `SHA1`, or `SHA256`.
        """
        return pulumi.get(self, "ipsec_integrity")

    @property
    @pulumi.getter(name="pfsGroup")
    def pfs_group(self) -> str:
        """
        The DH group used in IKE phase 2 for new child SA.
        Valid options are `ECP256`, `ECP384`, `PFS1`, `PFS2`, `PFS2048`, `PFS24`,
        or `None`.
        """
        return pulumi.get(self, "pfs_group")

    @property
    @pulumi.getter(name="saDatasize")
    def sa_datasize(self) -> float:
        """
        The IPSec SA payload size in KB. Must be at least
        `1024` KB.
        """
        return pulumi.get(self, "sa_datasize")

    @property
    @pulumi.getter(name="saLifetime")
    def sa_lifetime(self) -> float:
        """
        The IPSec SA lifetime in seconds. Must be at least
        `300` seconds.
        """
        return pulumi.get(self, "sa_lifetime")


@pulumi.output_type
class GetGatewayConnectionTrafficSelectorPolicyResult(dict):
    def __init__(__self__, *,
                 local_address_cidrs: List[str],
                 remote_address_cidrs: List[str]):
        """
        :param List[str] local_address_cidrs: List of local CIDRs.
        :param List[str] remote_address_cidrs: List of remote CIDRs.
        """
        pulumi.set(__self__, "local_address_cidrs", local_address_cidrs)
        pulumi.set(__self__, "remote_address_cidrs", remote_address_cidrs)

    @property
    @pulumi.getter(name="localAddressCidrs")
    def local_address_cidrs(self) -> List[str]:
        """
        List of local CIDRs.
        """
        return pulumi.get(self, "local_address_cidrs")

    @property
    @pulumi.getter(name="remoteAddressCidrs")
    def remote_address_cidrs(self) -> List[str]:
        """
        List of remote CIDRs.
        """
        return pulumi.get(self, "remote_address_cidrs")


@pulumi.output_type
class GetNetworkInterfaceIpConfigurationResult(dict):
    def __init__(__self__, *,
                 application_gateway_backend_address_pools_ids: List[str],
                 application_security_group_ids: List[str],
                 load_balancer_backend_address_pools_ids: List[str],
                 load_balancer_inbound_nat_rules_ids: List[str],
                 name: str,
                 primary: bool,
                 private_ip_address: str,
                 private_ip_address_allocation: str,
                 private_ip_address_version: str,
                 public_ip_address_id: str,
                 subnet_id: str):
        """
        :param List[str] application_gateway_backend_address_pools_ids: A list of Backend Address Pool ID's within a Application Gateway that this Network Interface is connected to.
        :param List[str] load_balancer_backend_address_pools_ids: A list of Backend Address Pool ID's within a Load Balancer that this Network Interface is connected to.
        :param List[str] load_balancer_inbound_nat_rules_ids: A list of Inbound NAT Rule ID's within a Load Balancer that this Network Interface is connected to.
        :param str name: Specifies the name of the Network Interface.
        :param bool primary: is this the Primary IP Configuration for this Network Interface?
        :param str private_ip_address: The Private IP Address assigned to this Network Interface.
        :param str private_ip_address_allocation: The IP Address allocation type for the Private address, such as `Dynamic` or `Static`.
        :param str public_ip_address_id: The ID of the Public IP Address which is connected to this Network Interface.
        :param str subnet_id: The ID of the Subnet which the Network Interface is connected to.
        """
        pulumi.set(__self__, "application_gateway_backend_address_pools_ids", application_gateway_backend_address_pools_ids)
        pulumi.set(__self__, "application_security_group_ids", application_security_group_ids)
        pulumi.set(__self__, "load_balancer_backend_address_pools_ids", load_balancer_backend_address_pools_ids)
        pulumi.set(__self__, "load_balancer_inbound_nat_rules_ids", load_balancer_inbound_nat_rules_ids)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "primary", primary)
        pulumi.set(__self__, "private_ip_address", private_ip_address)
        pulumi.set(__self__, "private_ip_address_allocation", private_ip_address_allocation)
        pulumi.set(__self__, "private_ip_address_version", private_ip_address_version)
        pulumi.set(__self__, "public_ip_address_id", public_ip_address_id)
        pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="applicationGatewayBackendAddressPoolsIds")
    def application_gateway_backend_address_pools_ids(self) -> List[str]:
        """
        A list of Backend Address Pool ID's within a Application Gateway that this Network Interface is connected to.
        """
        return pulumi.get(self, "application_gateway_backend_address_pools_ids")

    @property
    @pulumi.getter(name="applicationSecurityGroupIds")
    def application_security_group_ids(self) -> List[str]:
        return pulumi.get(self, "application_security_group_ids")

    @property
    @pulumi.getter(name="loadBalancerBackendAddressPoolsIds")
    def load_balancer_backend_address_pools_ids(self) -> List[str]:
        """
        A list of Backend Address Pool ID's within a Load Balancer that this Network Interface is connected to.
        """
        return pulumi.get(self, "load_balancer_backend_address_pools_ids")

    @property
    @pulumi.getter(name="loadBalancerInboundNatRulesIds")
    def load_balancer_inbound_nat_rules_ids(self) -> List[str]:
        """
        A list of Inbound NAT Rule ID's within a Load Balancer that this Network Interface is connected to.
        """
        return pulumi.get(self, "load_balancer_inbound_nat_rules_ids")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Network Interface.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def primary(self) -> bool:
        """
        is this the Primary IP Configuration for this Network Interface?
        """
        return pulumi.get(self, "primary")

    @property
    @pulumi.getter(name="privateIpAddress")
    def private_ip_address(self) -> str:
        """
        The Private IP Address assigned to this Network Interface.
        """
        return pulumi.get(self, "private_ip_address")

    @property
    @pulumi.getter(name="privateIpAddressAllocation")
    def private_ip_address_allocation(self) -> str:
        """
        The IP Address allocation type for the Private address, such as `Dynamic` or `Static`.
        """
        return pulumi.get(self, "private_ip_address_allocation")

    @property
    @pulumi.getter(name="privateIpAddressVersion")
    def private_ip_address_version(self) -> str:
        return pulumi.get(self, "private_ip_address_version")

    @property
    @pulumi.getter(name="publicIpAddressId")
    def public_ip_address_id(self) -> str:
        """
        The ID of the Public IP Address which is connected to this Network Interface.
        """
        return pulumi.get(self, "public_ip_address_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        The ID of the Subnet which the Network Interface is connected to.
        """
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class GetNetworkSecurityGroupSecurityRuleResult(dict):
    def __init__(__self__, *,
                 access: str,
                 description: str,
                 destination_address_prefix: str,
                 destination_address_prefixes: List[str],
                 destination_port_range: str,
                 destination_port_ranges: List[str],
                 direction: str,
                 name: str,
                 priority: float,
                 protocol: str,
                 source_address_prefix: str,
                 source_address_prefixes: List[str],
                 source_port_range: str,
                 source_port_ranges: List[str],
                 destination_application_security_group_ids: Optional[List[str]] = None,
                 source_application_security_group_ids: Optional[List[str]] = None):
        """
        :param str access: Is network traffic is allowed or denied?
        :param str description: The description for this rule.
        :param str destination_address_prefix: CIDR or destination IP range or * to match any IP.
        :param List[str] destination_address_prefixes: A list of CIDRs or destination IP ranges.
        :param str destination_port_range: The Destination Port or Range.
        :param str direction: The direction specifies if rule will be evaluated on incoming or outgoing traffic.
        :param str name: Specifies the Name of the Network Security Group.
        :param float priority: The priority of the rule
        :param str protocol: The network protocol this rule applies to.
        :param str source_address_prefix: CIDR or source IP range or * to match any IP.
        :param List[str] source_address_prefixes: A list of CIDRs or source IP ranges.
        :param str source_port_range: The Source Port or Range.
        :param List[str] destination_application_security_group_ids: A List of destination Application Security Group ID's
        :param List[str] source_application_security_group_ids: A List of source Application Security Group ID's
        """
        pulumi.set(__self__, "access", access)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "destination_address_prefix", destination_address_prefix)
        pulumi.set(__self__, "destination_address_prefixes", destination_address_prefixes)
        pulumi.set(__self__, "destination_port_range", destination_port_range)
        pulumi.set(__self__, "destination_port_ranges", destination_port_ranges)
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "source_address_prefix", source_address_prefix)
        pulumi.set(__self__, "source_address_prefixes", source_address_prefixes)
        pulumi.set(__self__, "source_port_range", source_port_range)
        pulumi.set(__self__, "source_port_ranges", source_port_ranges)
        if destination_application_security_group_ids is not None:
            pulumi.set(__self__, "destination_application_security_group_ids", destination_application_security_group_ids)
        if source_application_security_group_ids is not None:
            pulumi.set(__self__, "source_application_security_group_ids", source_application_security_group_ids)

    @property
    @pulumi.getter
    def access(self) -> str:
        """
        Is network traffic is allowed or denied?
        """
        return pulumi.get(self, "access")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The description for this rule.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="destinationAddressPrefix")
    def destination_address_prefix(self) -> str:
        """
        CIDR or destination IP range or * to match any IP.
        """
        return pulumi.get(self, "destination_address_prefix")

    @property
    @pulumi.getter(name="destinationAddressPrefixes")
    def destination_address_prefixes(self) -> List[str]:
        """
        A list of CIDRs or destination IP ranges.
        """
        return pulumi.get(self, "destination_address_prefixes")

    @property
    @pulumi.getter(name="destinationPortRange")
    def destination_port_range(self) -> str:
        """
        The Destination Port or Range.
        """
        return pulumi.get(self, "destination_port_range")

    @property
    @pulumi.getter(name="destinationPortRanges")
    def destination_port_ranges(self) -> List[str]:
        return pulumi.get(self, "destination_port_ranges")

    @property
    @pulumi.getter
    def direction(self) -> str:
        """
        The direction specifies if rule will be evaluated on incoming or outgoing traffic.
        """
        return pulumi.get(self, "direction")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the Name of the Network Security Group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def priority(self) -> float:
        """
        The priority of the rule
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The network protocol this rule applies to.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="sourceAddressPrefix")
    def source_address_prefix(self) -> str:
        """
        CIDR or source IP range or * to match any IP.
        """
        return pulumi.get(self, "source_address_prefix")

    @property
    @pulumi.getter(name="sourceAddressPrefixes")
    def source_address_prefixes(self) -> List[str]:
        """
        A list of CIDRs or source IP ranges.
        """
        return pulumi.get(self, "source_address_prefixes")

    @property
    @pulumi.getter(name="sourcePortRange")
    def source_port_range(self) -> str:
        """
        The Source Port or Range.
        """
        return pulumi.get(self, "source_port_range")

    @property
    @pulumi.getter(name="sourcePortRanges")
    def source_port_ranges(self) -> List[str]:
        return pulumi.get(self, "source_port_ranges")

    @property
    @pulumi.getter(name="destinationApplicationSecurityGroupIds")
    def destination_application_security_group_ids(self) -> Optional[List[str]]:
        """
        A List of destination Application Security Group ID's
        """
        return pulumi.get(self, "destination_application_security_group_ids")

    @property
    @pulumi.getter(name="sourceApplicationSecurityGroupIds")
    def source_application_security_group_ids(self) -> Optional[List[str]]:
        """
        A List of source Application Security Group ID's
        """
        return pulumi.get(self, "source_application_security_group_ids")


@pulumi.output_type
class GetPublicIPsPublicIpResult(dict):
    def __init__(__self__, *,
                 domain_name_label: str,
                 fqdn: str,
                 id: str,
                 ip_address: str,
                 name: str):
        """
        :param str domain_name_label: The Domain Name Label of the Public IP Address
        :param str fqdn: The FQDN of the Public IP Address
        :param str id: The ID of the Public IP Address
        :param str name: The Name of the Public IP Address
        """
        pulumi.set(__self__, "domain_name_label", domain_name_label)
        pulumi.set(__self__, "fqdn", fqdn)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "ip_address", ip_address)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="domainNameLabel")
    def domain_name_label(self) -> str:
        """
        The Domain Name Label of the Public IP Address
        """
        return pulumi.get(self, "domain_name_label")

    @property
    @pulumi.getter
    def fqdn(self) -> str:
        """
        The FQDN of the Public IP Address
        """
        return pulumi.get(self, "fqdn")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Public IP Address
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> str:
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Name of the Public IP Address
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetRouteFilterRuleResult(dict):
    def __init__(__self__, *,
                 access: str,
                 communities: List[str],
                 name: str,
                 rule_type: str):
        """
        :param str access: The access type of the rule
        :param List[str] communities: The collection for bgp community values.
        :param str name: The Name of this Route Filter.
        :param str rule_type: The Route Filter Rule Type.
        """
        pulumi.set(__self__, "access", access)
        pulumi.set(__self__, "communities", communities)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "rule_type", rule_type)

    @property
    @pulumi.getter
    def access(self) -> str:
        """
        The access type of the rule
        """
        return pulumi.get(self, "access")

    @property
    @pulumi.getter
    def communities(self) -> List[str]:
        """
        The collection for bgp community values.
        """
        return pulumi.get(self, "communities")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The Name of this Route Filter.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="ruleType")
    def rule_type(self) -> str:
        """
        The Route Filter Rule Type.
        """
        return pulumi.get(self, "rule_type")


@pulumi.output_type
class GetRouteTableRouteResult(dict):
    def __init__(__self__, *,
                 address_prefix: str,
                 name: str,
                 next_hop_in_ip_address: str,
                 next_hop_type: str):
        """
        :param str address_prefix: The destination CIDR to which the route applies.
        :param str name: The name of the Route Table.
        :param str next_hop_in_ip_address: Contains the IP address packets should be forwarded to.
        :param str next_hop_type: The type of Azure hop the packet should be sent to.
        """
        pulumi.set(__self__, "address_prefix", address_prefix)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "next_hop_in_ip_address", next_hop_in_ip_address)
        pulumi.set(__self__, "next_hop_type", next_hop_type)

    @property
    @pulumi.getter(name="addressPrefix")
    def address_prefix(self) -> str:
        """
        The destination CIDR to which the route applies.
        """
        return pulumi.get(self, "address_prefix")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Route Table.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="nextHopInIpAddress")
    def next_hop_in_ip_address(self) -> str:
        """
        Contains the IP address packets should be forwarded to.
        """
        return pulumi.get(self, "next_hop_in_ip_address")

    @property
    @pulumi.getter(name="nextHopType")
    def next_hop_type(self) -> str:
        """
        The type of Azure hop the packet should be sent to.
        """
        return pulumi.get(self, "next_hop_type")


@pulumi.output_type
class GetVirtualNetworkGatewayBgpSettingResult(dict):
    def __init__(__self__, *,
                 asn: float,
                 peer_weight: float,
                 peering_address: str):
        """
        :param float asn: The Autonomous System Number (ASN) to use as part of the BGP.
        :param float peer_weight: The weight added to routes which have been learned
               through BGP peering.
        :param str peering_address: The BGP peer IP address of the virtual network
               gateway. This address is needed to configure the created gateway as a BGP Peer
               on the on-premises VPN devices.
        """
        pulumi.set(__self__, "asn", asn)
        pulumi.set(__self__, "peer_weight", peer_weight)
        pulumi.set(__self__, "peering_address", peering_address)

    @property
    @pulumi.getter
    def asn(self) -> float:
        """
        The Autonomous System Number (ASN) to use as part of the BGP.
        """
        return pulumi.get(self, "asn")

    @property
    @pulumi.getter(name="peerWeight")
    def peer_weight(self) -> float:
        """
        The weight added to routes which have been learned
        through BGP peering.
        """
        return pulumi.get(self, "peer_weight")

    @property
    @pulumi.getter(name="peeringAddress")
    def peering_address(self) -> str:
        """
        The BGP peer IP address of the virtual network
        gateway. This address is needed to configure the created gateway as a BGP Peer
        on the on-premises VPN devices.
        """
        return pulumi.get(self, "peering_address")


@pulumi.output_type
class GetVirtualNetworkGatewayIpConfigurationResult(dict):
    def __init__(__self__, *,
                 name: str,
                 private_ip_address_allocation: str,
                 public_ip_address_id: str,
                 subnet_id: str):
        """
        :param str name: Specifies the name of the Virtual Network Gateway.
        :param str private_ip_address_allocation: Defines how the private IP address
               of the gateways virtual interface is assigned.
        :param str public_ip_address_id: The ID of the Public IP Address associated
               with the Virtual Network Gateway.
        :param str subnet_id: The ID of the gateway subnet of a virtual network in
               which the virtual network gateway will be created. It is mandatory that
               the associated subnet is named `GatewaySubnet`. Therefore, each virtual
               network can contain at most a single Virtual Network Gateway.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "private_ip_address_allocation", private_ip_address_allocation)
        pulumi.set(__self__, "public_ip_address_id", public_ip_address_id)
        pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Virtual Network Gateway.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="privateIpAddressAllocation")
    def private_ip_address_allocation(self) -> str:
        """
        Defines how the private IP address
        of the gateways virtual interface is assigned.
        """
        return pulumi.get(self, "private_ip_address_allocation")

    @property
    @pulumi.getter(name="publicIpAddressId")
    def public_ip_address_id(self) -> str:
        """
        The ID of the Public IP Address associated
        with the Virtual Network Gateway.
        """
        return pulumi.get(self, "public_ip_address_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        The ID of the gateway subnet of a virtual network in
        which the virtual network gateway will be created. It is mandatory that
        the associated subnet is named `GatewaySubnet`. Therefore, each virtual
        network can contain at most a single Virtual Network Gateway.
        """
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class GetVirtualNetworkGatewayVpnClientConfigurationResult(dict):
    def __init__(__self__, *,
                 aad_audience: str,
                 aad_issuer: str,
                 aad_tenant: str,
                 address_spaces: List[str],
                 radius_server_address: str,
                 radius_server_secret: str,
                 revoked_certificates: List['outputs.GetVirtualNetworkGatewayVpnClientConfigurationRevokedCertificateResult'],
                 root_certificates: List['outputs.GetVirtualNetworkGatewayVpnClientConfigurationRootCertificateResult'],
                 vpn_client_protocols: List[str]):
        """
        :param str aad_audience: The client id of the Azure VPN application.
               See [Create an Active Directory (AD) tenant for P2S OpenVPN protocol connections](https://docs.microsoft.com/en-gb/azure/vpn-gateway/openvpn-azure-ad-tenant-multi-app) for values
               This setting is incompatible with the use of
               `root_certificate` and `revoked_certificate`, `radius_server_address`, and `radius_server_secret`.
        :param str aad_issuer: The STS url for your tenant
               This setting is incompatible with the use of
               `root_certificate` and `revoked_certificate`, `radius_server_address`, and `radius_server_secret`.
        :param str aad_tenant: AzureAD Tenant URL
               This setting is incompatible with the use of
               `root_certificate` and `revoked_certificate`, `radius_server_address`, and `radius_server_secret`.
        :param List[str] address_spaces: The address space out of which ip addresses for
               vpn clients will be taken. You can provide more than one address space, e.g.
               in CIDR notation.
        :param str radius_server_address: The address of the Radius server.
               This setting is incompatible with the use of
               `aad_tenant`, `aad_audience`, `aad_issuer`, `root_certificate` and `revoked_certificate`.
        :param str radius_server_secret: The secret used by the Radius server.
               This setting is incompatible with the use of
               `aad_tenant`, `aad_audience`, `aad_issuer`, `root_certificate` and `revoked_certificate`.
        :param List['GetVirtualNetworkGatewayVpnClientConfigurationRevokedCertificateArgs'] revoked_certificates: One or more `revoked_certificate` blocks which
               are defined below.
               This setting is incompatible with the use of
               `aad_tenant`, `aad_audience`, `aad_issuer`, `radius_server_address`, and `radius_server_secret`.
        :param List['GetVirtualNetworkGatewayVpnClientConfigurationRootCertificateArgs'] root_certificates: One or more `root_certificate` blocks which are
               defined below. These root certificates are used to sign the client certificate
               used by the VPN clients to connect to the gateway.
               This setting is incompatible with the use of
               `aad_tenant`, `aad_audience`, `aad_issuer`, `radius_server_address`, and `radius_server_secret`.
        :param List[str] vpn_client_protocols: List of the protocols supported by the vpn client.
               The supported values are `SSTP`, `IkeV2` and `OpenVPN`.
        """
        pulumi.set(__self__, "aad_audience", aad_audience)
        pulumi.set(__self__, "aad_issuer", aad_issuer)
        pulumi.set(__self__, "aad_tenant", aad_tenant)
        pulumi.set(__self__, "address_spaces", address_spaces)
        pulumi.set(__self__, "radius_server_address", radius_server_address)
        pulumi.set(__self__, "radius_server_secret", radius_server_secret)
        pulumi.set(__self__, "revoked_certificates", revoked_certificates)
        pulumi.set(__self__, "root_certificates", root_certificates)
        pulumi.set(__self__, "vpn_client_protocols", vpn_client_protocols)

    @property
    @pulumi.getter(name="aadAudience")
    def aad_audience(self) -> str:
        """
        The client id of the Azure VPN application.
        See [Create an Active Directory (AD) tenant for P2S OpenVPN protocol connections](https://docs.microsoft.com/en-gb/azure/vpn-gateway/openvpn-azure-ad-tenant-multi-app) for values
        This setting is incompatible with the use of
        `root_certificate` and `revoked_certificate`, `radius_server_address`, and `radius_server_secret`.
        """
        return pulumi.get(self, "aad_audience")

    @property
    @pulumi.getter(name="aadIssuer")
    def aad_issuer(self) -> str:
        """
        The STS url for your tenant
        This setting is incompatible with the use of
        `root_certificate` and `revoked_certificate`, `radius_server_address`, and `radius_server_secret`.
        """
        return pulumi.get(self, "aad_issuer")

    @property
    @pulumi.getter(name="aadTenant")
    def aad_tenant(self) -> str:
        """
        AzureAD Tenant URL
        This setting is incompatible with the use of
        `root_certificate` and `revoked_certificate`, `radius_server_address`, and `radius_server_secret`.
        """
        return pulumi.get(self, "aad_tenant")

    @property
    @pulumi.getter(name="addressSpaces")
    def address_spaces(self) -> List[str]:
        """
        The address space out of which ip addresses for
        vpn clients will be taken. You can provide more than one address space, e.g.
        in CIDR notation.
        """
        return pulumi.get(self, "address_spaces")

    @property
    @pulumi.getter(name="radiusServerAddress")
    def radius_server_address(self) -> str:
        """
        The address of the Radius server.
        This setting is incompatible with the use of
        `aad_tenant`, `aad_audience`, `aad_issuer`, `root_certificate` and `revoked_certificate`.
        """
        return pulumi.get(self, "radius_server_address")

    @property
    @pulumi.getter(name="radiusServerSecret")
    def radius_server_secret(self) -> str:
        """
        The secret used by the Radius server.
        This setting is incompatible with the use of
        `aad_tenant`, `aad_audience`, `aad_issuer`, `root_certificate` and `revoked_certificate`.
        """
        return pulumi.get(self, "radius_server_secret")

    @property
    @pulumi.getter(name="revokedCertificates")
    def revoked_certificates(self) -> List['outputs.GetVirtualNetworkGatewayVpnClientConfigurationRevokedCertificateResult']:
        """
        One or more `revoked_certificate` blocks which
        are defined below.
        This setting is incompatible with the use of
        `aad_tenant`, `aad_audience`, `aad_issuer`, `radius_server_address`, and `radius_server_secret`.
        """
        return pulumi.get(self, "revoked_certificates")

    @property
    @pulumi.getter(name="rootCertificates")
    def root_certificates(self) -> List['outputs.GetVirtualNetworkGatewayVpnClientConfigurationRootCertificateResult']:
        """
        One or more `root_certificate` blocks which are
        defined below. These root certificates are used to sign the client certificate
        used by the VPN clients to connect to the gateway.
        This setting is incompatible with the use of
        `aad_tenant`, `aad_audience`, `aad_issuer`, `radius_server_address`, and `radius_server_secret`.
        """
        return pulumi.get(self, "root_certificates")

    @property
    @pulumi.getter(name="vpnClientProtocols")
    def vpn_client_protocols(self) -> List[str]:
        """
        List of the protocols supported by the vpn client.
        The supported values are `SSTP`, `IkeV2` and `OpenVPN`.
        """
        return pulumi.get(self, "vpn_client_protocols")


@pulumi.output_type
class GetVirtualNetworkGatewayVpnClientConfigurationRevokedCertificateResult(dict):
    def __init__(__self__, *,
                 name: str,
                 thumbprint: str):
        """
        :param str name: Specifies the name of the Virtual Network Gateway.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Virtual Network Gateway.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def thumbprint(self) -> str:
        return pulumi.get(self, "thumbprint")


@pulumi.output_type
class GetVirtualNetworkGatewayVpnClientConfigurationRootCertificateResult(dict):
    def __init__(__self__, *,
                 name: str,
                 public_cert_data: str):
        """
        :param str name: Specifies the name of the Virtual Network Gateway.
        :param str public_cert_data: The SHA1 thumbprint of the certificate to be revoked.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "public_cert_data", public_cert_data)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Specifies the name of the Virtual Network Gateway.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="publicCertData")
    def public_cert_data(self) -> str:
        """
        The SHA1 thumbprint of the certificate to be revoked.
        """
        return pulumi.get(self, "public_cert_data")


